{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LeR complete examples\n",
    "\n",
    "* Please refer to the [documentation](https://ler.readthedocs.io/en/latest/) for more details.\n",
    "\n",
    "## TOC:\n",
    "\n",
    "* [Short lensed or unlensed BBH example with three detectors](https://ler.readthedocs.io/en/latest/examples/rates/LeR%20complete%20examples.html#Short-lensed-or-unlensed-BBH-example-with-three-detectors)\n",
    "  * [Simulation of the GW CBC population (unlensed)](###bullet-one-one)\n",
    "  * [Calculation of unlensed rates](###bullet-one-two)\n",
    "  * [Simulation of the GW CBC population (lensed)](###bullet-one-three)\n",
    "  * [Calculation of lensed rates](###bullet-one-four)\n",
    "  * [Comparison of the rates](###bullet-one-five)\n",
    "  * [Getting generated parameters](###bullet-one-six)\n",
    "  * [Manually changing paramters and recompute the rates](###bullet-one-seven)\n",
    "  * [Plot the generated parameters](###bullet-one-seven)\n",
    "  \n",
    "* [Using custom functions and parameters](##bullet-two)\n",
    "  * [Defining custom functions and parameters](###bullet-two-one)\n",
    "  * [LeR initialization with custom functions and parameters](###bullet-two-two)\n",
    "  * [Sampling (Unlensed)](###bullet-two-three)\n",
    "  * [Sampling (Lensed)](###bullet-two-four)\n",
    "  * [Rate calculation and comparison](###bullet-two-five)\n",
    "\n",
    "* [Uning available model functions](##bullet-three)\n",
    "  * [Comparison of mass distribution model](###bullet-three-one)\n",
    "  * [Comparison of Axis-ratio model of the lensing galaxy](###bullet-three-two)\n",
    "\n",
    "* [Generating particular number of detectable events](##bullet-four)\n",
    "  * [Unlensed case](###bullet-four-one)\n",
    "  * [Lensed case](###bullet-four-two)\n",
    "  \n",
    "* [Using custom detection criteria](##bullet-five)\n",
    "  * [Defining custom detection criteria](###bullet-five-one)\n",
    "  * [Testing the custom detection criteria](###bullet-five-two)\n",
    "  * [Using custom detection criteria with LeR](###bullet-five-three)\n",
    "  * [Analysis: SNR (with ANN) + SNR recalculation (inner product)](###bullet-five-four)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Short lensed or unlensed BBH example with three detectors.\n",
    "\n",
    "* This part of the notebook is a short example to simulate lensed and unlensed binary black hole mergers and calculate their rates ($yr^{-1}$) and finally compare the results.\n",
    "  \n",
    "* All the outputs are saved in the `ler_data` directory by default.\n",
    "\n",
    "* `ler` package heavily relies on multiprocessing capability of python, and some of the multiprocessing settings are set by [default](https://github.com/hemantaph/ler/blob/b2f75e7e4fe24f87cfdbf3dd65465252c15ac2bc/ler/__init__.py#L13) when calling the package. If issue arises, please raise issue in [github.ler.issue](https://github.com/hemantaph/ler/issues)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setting multiprocessing start method to 'fork'\n"
     ]
    }
   ],
   "source": [
    "# call the LeR class\n",
    "from ler.rates import LeR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* You can check for more details on `LeR` class from either the [documentation](https://ler.readthedocs.io/en/latest/) or by calling `help(LeR)` or `LeR?` (in the Jupyter Notebook).\n",
    "\n",
    "* Depending on the number of CPU cores used and microprocessor architecture, `LeR` class initialization will take some time to generate interpolation data for the models. Please be patient. e.g. it takes 1m 56s for 4 cores in M2 pro Aplle intel chip 16GB RAM.\n",
    "\n",
    "* The generated interpolation data is saved and will be call automatically when the same model is used again. If user wants to regenerate the interpolation data, please set `create_new_interpolator=True` in the `LeR` class initialization. Or you can simply delete the `interpolator_pickle` directory or specific path in the `interpolator_pickle` directory.\n",
    "  \n",
    "* if you don't want the models and its parameters to print. Default is True.\n",
    "\n",
    "    ```ler = LeR(verbose=False)```\n",
    "    \n",
    "* set 'npool' according to your machine's available CPU cores. Default is 4.\n",
    "* to check no. of cores, \n",
    "\n",
    "    ```\n",
    "    import multiprocessing as mp\n",
    "    print(mp.cpu_count())\n",
    "    ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z_to_luminosity_distance interpolator will be loaded from ./interpolator_pickle/z_to_luminosity_distance/z_to_luminosity_distance_0.pickle\n",
      "differential_comoving_volume interpolator will be loaded from ./interpolator_pickle/differential_comoving_volume/differential_comoving_volume_0.pickle\n",
      "merger_rate_density interpolator will be loaded from ./interpolator_pickle/merger_rate_density/merger_rate_density_0.pickle\n",
      "z_to_Dc interpolator will be loaded from ./interpolator_pickle/z_to_Dc/z_to_Dc_0.pickle\n",
      "Dc_to_z interpolator will be loaded from ./interpolator_pickle/Dc_to_z/Dc_to_z_0.pickle\n",
      "angular_diameter_distance interpolator will be loaded from ./interpolator_pickle/angular_diameter_distance/angular_diameter_distance_0.pickle\n",
      "differential_comoving_volume interpolator will be loaded from ./interpolator_pickle/differential_comoving_volume/differential_comoving_volume_2.pickle\n",
      "velocity_dispersion_ewoud interpolator will be loaded from ./interpolator_pickle/velocity_dispersion_ewoud/velocity_dispersion_ewoud_0.pickle\n",
      "optical_depth_SIE_hemanta interpolator will be loaded from ./interpolator_pickle/optical_depth_SIE_hemanta/optical_depth_SIE_hemanta_0.pickle\n",
      "input_params_image {'n_min_images': 2, 'n_max_images': 4, 'geocent_time_min': 1126259462.4, 'geocent_time_max': 1756979462.4, 'lens_model_list': ['EPL_NUMBA', 'SHEAR'], 'source_priors': None, 'source_priors_params': None, 'spin_zero': True, 'spin_precession': False}\n",
      "luminosity_distance_to_z interpolator will be loaded from ./interpolator_pickle/luminosity_distance_to_z/luminosity_distance_to_z_0.pickle\n",
      "psds not given. Choosing bilby's default psds\n",
      "Interpolator will be loaded for L1 detector from ./interpolator_pickle/L1/partialSNR_dict_0.pickle\n",
      "Interpolator will be loaded for H1 detector from ./interpolator_pickle/H1/partialSNR_dict_0.pickle\n",
      "Interpolator will be loaded for V1 detector from ./interpolator_pickle/V1/partialSNR_dict_0.pickle\n",
      "\n",
      " # LeR set up params:\n",
      "npool = 4,\n",
      "z_min = 0.0,\n",
      "z_max = 10.0,\n",
      "event_type = 'BBH',\n",
      "size = 100000,\n",
      "batch_size = 50000,\n",
      "cosmology = LambdaCDM(H0=70.0 km / (Mpc s), Om0=0.3, Ode0=0.7, Tcmb0=0.0 K, Neff=3.04, m_nu=None, Ob0=None),\n",
      "snr_finder = <bound method GWSNR.snr of <gwsnr.gwsnr.GWSNR object at 0x11251f9d0>>,\n",
      "json_file_names = {'ler_params': 'ler_params.json', 'unlensed_param': 'unlensed_param.json', 'unlensed_param_detectable': 'unlensed_param_detectable.json', 'lensed_param': 'lensed_param.json', 'lensed_param_detectable': 'lensed_param_detectable.json'},\n",
      "interpolator_directory = './interpolator_pickle',\n",
      "ler_directory = './ler_data',\n",
      "\n",
      " # LeR also takes CBCSourceParameterDistribution class params as kwargs, as follows:\n",
      "source_priors = {'merger_rate_density': 'merger_rate_density_bbh_popI_II_oguri2018', 'source_frame_masses': 'binary_masses_BBH_popI_II_powerlaw_gaussian', 'zs': 'sample_source_redshift', 'geocent_time': 'sampler_uniform', 'ra': 'sampler_uniform', 'dec': 'sampler_cosine', 'phase': 'sampler_uniform', 'psi': 'sampler_uniform', 'theta_jn': 'sampler_sine'},\n",
      "source_priors_params = {'merger_rate_density': {'R0': 2.39e-08, 'b2': 1.6, 'b3': 2.0, 'b4': 30}, 'source_frame_masses': {'mminbh': 4.98, 'mmaxbh': 112.5, 'alpha': 3.78, 'mu_g': 32.27, 'sigma_g': 3.88, 'lambda_peak': 0.03, 'delta_m': 4.8, 'beta': 0.81}, 'zs': None, 'geocent_time': {'min_': 1238166018, 'max_': 1269702018}, 'ra': {'min_': 0.0, 'max_': 6.283185307179586}, 'dec': None, 'phase': {'min_': 0.0, 'max_': 6.283185307179586}, 'psi': {'min_': 0.0, 'max_': 3.141592653589793}, 'theta_jn': None},\n",
      "spin_zero = True,\n",
      "spin_precession = False,\n",
      "create_new_interpolator = False,\n",
      "\n",
      " # LeR also takes LensGalaxyParameterDistribution class params as kwargs, as follows:\n",
      "lens_type = 'epl_shear_galaxy',\n",
      "lens_functions = {'strong_lensing_condition': 'rjs_with_cross_section_SIE', 'optical_depth': 'optical_depth_SIE_hemanta', 'param_sampler_type': 'sample_all_routine'},\n",
      "lens_priors = {'source_redshift_sl': 'strongly_lensed_source_redshifts', 'lens_redshift': 'lens_redshift_SDSS_catalogue', 'velocity_dispersion': 'velocity_dispersion_ewoud', 'axis_ratio': 'axis_ratio_rayleigh', 'axis_rotation_angle': 'axis_rotation_angle_uniform', 'external_shear': 'shear_norm', 'density_profile_slope': 'density_profile_slope_normal', 'source_parameters': 'sample_gw_parameters'},\n",
      "lens_priors_params = {'source_redshift_sl': None, 'lens_redshift': None, 'velocity_dispersion': None, 'axis_ratio': {'q_min': 0.2, 'q_max': 1.0}, 'axis_rotation_angle': {'phi_min': 0.0, 'phi_max': 6.283185307179586}, 'external_shear': {'scale': 0.05}, 'density_profile_slope': {'mean': 2.0, 'std': 0.2}, 'source_parameters': None},\n",
      "\n",
      " # LeR also takes ImageProperties class params as kwargs, as follows:\n",
      "n_min_images = 2,\n",
      "n_max_images = 4,\n",
      "geocent_time_min = 1126259462.4,\n",
      "geocent_time_max = 1756979462.4,\n",
      "lens_model_list = ['EPL_NUMBA', 'SHEAR'],\n",
      "\n",
      " # LeR also takes gwsnr.GWSNR params as kwargs, as follows:\n",
      "mtot_min = 2.0,\n",
      "mtot_max = 184.98599853446768,\n",
      "ratio_min = 0.1,\n",
      "ratio_max = 1.0,\n",
      "mtot_resolution = 500,\n",
      "ratio_resolution = 50,\n",
      "sampling_frequency = 2048.0,\n",
      "waveform_approximant = 'IMRPhenomD',\n",
      "minimum_frequency = 20.0,\n",
      "snr_type = 'interpolation',\n",
      "psds = [PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/aLIGO_O4_high_asd.txt'), PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/aLIGO_O4_high_asd.txt'), PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/AdV_asd.txt')],\n",
      "ifos = None,\n",
      "interpolator_dir = './interpolator_pickle',\n",
      "gwsnr_verbose = False,\n",
      "multiprocessing_verbose = True,\n",
      "mtot_cut = True,\n",
      "\n",
      " For reference, the chosen source parameters are listed below:\n",
      "merger_rate_density = 'merger_rate_density_bbh_popI_II_oguri2018'\n",
      "merger_rate_density_params =  {'R0': 2.39e-08, 'b2': 1.6, 'b3': 2.0, 'b4': 30}\n",
      "source_frame_masses = 'binary_masses_BBH_popI_II_powerlaw_gaussian'\n",
      "source_frame_masses_params =  {'mminbh': 4.98, 'mmaxbh': 112.5, 'alpha': 3.78, 'mu_g': 32.27, 'sigma_g': 3.88, 'lambda_peak': 0.03, 'delta_m': 4.8, 'beta': 0.81}\n",
      "geocent_time = 'sampler_uniform'\n",
      "geocent_time_params =  {'min_': 1238166018, 'max_': 1269702018}\n",
      "ra = 'sampler_uniform'\n",
      "ra_params =  {'min_': 0.0, 'max_': 6.283185307179586}\n",
      "dec = 'sampler_cosine'\n",
      "dec_params =  None\n",
      "phase = 'sampler_uniform'\n",
      "phase_params =  {'min_': 0.0, 'max_': 6.283185307179586}\n",
      "psi = 'sampler_uniform'\n",
      "psi_params =  {'min_': 0.0, 'max_': 3.141592653589793}\n",
      "theta_jn = 'sampler_sine'\n",
      "theta_jn_params =  None\n",
      "\n",
      " For reference, the chosen lens related parameters and functions are listed below:\n",
      "lens_redshift = 'lens_redshift_SDSS_catalogue'\n",
      "lens_redshift_params =  None\n",
      "velocity_dispersion = 'velocity_dispersion_ewoud'\n",
      "velocity_dispersion_params =  None\n",
      "axis_ratio = 'axis_ratio_rayleigh'\n",
      "axis_ratio_params =  {'q_min': 0.2, 'q_max': 1.0}\n",
      "axis_rotation_angle = 'axis_rotation_angle_uniform'\n",
      "axis_rotation_angle_params =  {'phi_min': 0.0, 'phi_max': 6.283185307179586}\n",
      "shear = 'shear_norm'\n",
      "shear_params =  {'scale': 0.05}\n",
      "density_profile_slope = 'density_profile_slope_normal'\n",
      "density_profile_slope_params =  {'mean': 2.0, 'std': 0.2}\n",
      "Lens functions:\n",
      "strong_lensing_condition = 'rjs_with_cross_section_SIE'\n",
      "optical_depth = 'optical_depth_SIE_hemanta'\n"
     ]
    }
   ],
   "source": [
    "# LeR initialization with default arguments\n",
    "ler = LeR()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation of the GW CBC population (unlensed). <a class=\"anchor\" id=\"bullet-one-one\"></a>\n",
    "\n",
    "* this will generate a json file with the simulated population parameters.\n",
    "  \n",
    "* by default 100,000 events will be sampled with batches of 50,000. For more realistic results, keep batch_size=50000 and size>=1000000.\n",
    "  \n",
    "* results will be saved in the same directory as json file.\n",
    "  \n",
    "* `resume=True` will resume the simulation from the last saved batch.\n",
    "  \n",
    "* if you dont't need to save the file at the end of each batch sampling, set `save_batch=False` (default)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed params will be store in ./ler_data/unlensed_param.json\n",
      "chosen batch size = 50000 with total size = 100000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling gw source params...\n",
      "calculating snrs...\n",
      "Batch no. 2\n",
      "sampling gw source params...\n",
      "calculating snrs...\n",
      "saving all unlensed parameters in ./ler_data/unlensed_param.json \n"
     ]
    }
   ],
   "source": [
    "# ler.batch_size = 100000 # for faster computation\n",
    "unlensed_param = ler.unlensed_cbc_statistics(size=100000, resume=False, save_batch=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculation of unlensed rates. <a class=\"anchor\" id=\"bullet-one-two\"></a> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting unlensed_param from json file ./ler_data/unlensed_param.json...\n",
      "given detectability_condition == 'step_function'\n",
      "total unlensed rate (yr^-1): 432.7257078089194\n",
      "number of simulated unlensed detectable events: 418\n",
      "number of simulated all unlensed events: 100000\n",
      "storing detectable params in ./ler_data/unlensed_param_detectable.json\n"
     ]
    }
   ],
   "source": [
    "rate_unlensed, unlensed_param_detectable = ler.unlensed_rate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['zs', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'L1', 'H1', 'V1', 'snr_net'])\n"
     ]
    }
   ],
   "source": [
    "# look for parameters names included in the generated data\n",
    "print(unlensed_param_detectable.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation of the GW CBC population (lensed). <a class=\"anchor\" id=\"bullet-one-three\"></a> \n",
    "\n",
    "* this will generate a json file with the simulated source parameters, lensed parameters and image parameters.\n",
    "  \n",
    "* if the program hangs dues to memory issues,\n",
    "  * try reducing the batch size.\n",
    "  * and you can resume from the last saved batch. But you need to set save_batch=True.\n",
    "  * `save_batch=False` (default) will make the code run faster but you will not have the results saved in the end of each batch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lensed params will be store in ./ler_data/lensed_param.json\n",
      "chosen batch size = 50000 with total size = 100000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling lensed params...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:11<00:00, 4376.58it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n",
      "Batch no. 2\n",
      "sampling lensed params...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:11<00:00, 4262.07it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid sample found. Resampling 1 lensed events...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 11.91it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saving all lensed parameters in ./ler_data/lensed_param.json \n"
     ]
    }
   ],
   "source": [
    "# ler.batch_size = 50000\n",
    "lensed_param = ler.lensed_cbc_statistics(size=100000, resume=False, save_batch=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculation of lensed rates. <a class=\"anchor\" id=\"bullet-one-four\"></a> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting lensed_param from json file ./ler_data/lensed_param.json...\n",
      "given detectability_condition == step_function\n",
      "total lensed rate (yr^-1): 1.1690813631723105\n",
      "number of simulated lensed detectable events: 515\n",
      "number of simulated all lensed events: 100000\n",
      "storing detectable params in ./ler_data/lensed_param_detectable.json\n"
     ]
    }
   ],
   "source": [
    "ler.lensed_rate();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison of the rates. <a class=\"anchor\" id=\"bullet-one-five\"></a> \n",
    "\n",
    "* `ler.rate_ratio` function by default assumes data generated and stored in previous steps. Otherwise you have to provide the data or the file path."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed_rate: 432.7257078089194\n",
      "lensed_rate: 1.1690813631723105\n",
      "ratio: 370.1416526175006\n"
     ]
    }
   ],
   "source": [
    "ler.rate_ratio();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* if you want to calculate the rates, and compare it at the same time, run the following command.\n",
    "\n",
    "    ```rate_ratio, unlensed_param_detectable, lensed_param_detectable =ler.rate_comparison_with_rate_calculation()```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Note: The above example is for spin-less systems. IMRPhenomD (spin-less) is the default waveform approximant. To see LeR configuration, run\n",
    "\n",
    "    ```ler.print_all_params()```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting generated parameters. <a class=\"anchor\" id=\"bullet-one-six\"></a> \n",
    "\n",
    "* what are the saved files?\n",
    "\n",
    "* all saved files are in the `ler_data` directory by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ler directory: ./ler_data\n",
      "ler json file names: {'ler_params': 'ler_params.json', 'unlensed_param': 'unlensed_param.json', 'unlensed_param_detectable': 'unlensed_param_detectable.json', 'lensed_param': 'lensed_param.json', 'lensed_param_detectable': 'lensed_param_detectable.json'}\n"
     ]
    }
   ],
   "source": [
    "#ler.json_file_names, ler.ler_directory\n",
    "print(f\"ler directory: {ler.ler_directory}\")\n",
    "print(f\"ler json file names: {ler.json_file_names}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* you can use ler attributes or call the relevant json file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed_param_detectable keys: dict_keys(['zs', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'L1', 'H1', 'V1', 'snr_net'])\n",
      "lensed_param_detectable keys: dict_keys(['zl', 'zs', 'sigma', 'q', 'theta_E', 'phi', 'e1', 'e2', 'gamma1', 'gamma2', 'gamma', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'x0_image_positions', 'x1_image_positions', 'magnifications', 'time_delays', 'image_type', 'n_images', 'effective_luminosity_distance', 'effective_geocent_time', 'snr_net', 'L1', 'H1', 'V1'])\n"
     ]
    }
   ],
   "source": [
    "# the generated parameters are not store in the ler instance, but in the json files\n",
    "# you can access the generated parameters from the json files as shown below\n",
    "unlensed_param_detectable = ler.unlensed_param_detectable\n",
    "lensed_param_detectable = ler.lensed_param_detectable\n",
    "# unlensed_param = ler.unlensed_param\n",
    "# lensed_param = ler.lensed_param\n",
    "\n",
    "# print keys of the generated parameters\n",
    "print(f\"unlensed_param_detectable keys: {unlensed_param_detectable.keys()}\")\n",
    "print(f\"lensed_param_detectable keys: {lensed_param_detectable.keys()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* here is another way to access the generated parameters from the json files\n",
    "\n",
    "* `get_param_from_json` and `load_json` functions from `ler.utils` sub-module will be use in the following examples. `get_param_from_json` will automatically assume the dictionary value is a list and will be converted to a numpy array, while `load_json` will return the json file's dictionary as it is.\n",
    "\n",
    "* `get_param_from_json` will recognize numpy specific data types (e.g. nan and inf) and convert them to numpy arrays.\n",
    "\n",
    "* to save data as dictionary, use `save_json` or `append_json` function from `ler.utils` sub-module.\n",
    "\n",
    "* all function usage of `ler.utils` sub-module can be found in the [ler.git](https://github.com/hemantaph/ler/blob/main/examples/utils/utils_functions.ipynb) example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed_param_detectable keys: dict_keys(['zs', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'L1', 'H1', 'V1', 'snr_net'])\n",
      "lensed_param_detectable keys: dict_keys(['zl', 'zs', 'sigma', 'q', 'theta_E', 'phi', 'e1', 'e2', 'gamma1', 'gamma2', 'gamma', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'x0_image_positions', 'x1_image_positions', 'magnifications', 'time_delays', 'image_type', 'n_images', 'effective_luminosity_distance', 'effective_geocent_time', 'snr_net', 'L1', 'H1', 'V1'])\n"
     ]
    }
   ],
   "source": [
    "from ler.utils import get_param_from_json\n",
    "\n",
    "unlensed_param_detectable = get_param_from_json(ler.ler_directory+'/'+ler.json_file_names['unlensed_param_detectable'])\n",
    "lensed_param_detectable = get_param_from_json(ler.ler_directory+'/'+ler.json_file_names['lensed_param_detectable'])\n",
    "# unlensed_param = get_param_from_json(ler.ler_directory+'/'+ler.json_file_names['unlensed_param'])\n",
    "# lensed_param = get_param_from_json(ler.ler_directory+'/'+ler.json_file_names['lensed_param'])\n",
    "\n",
    "# print keys of the generated parameters\n",
    "print(f\"unlensed_param_detectable keys: {unlensed_param_detectable.keys()}\")\n",
    "print(f\"lensed_param_detectable keys: {lensed_param_detectable.keys()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Note: all LeR initialization parameters and some important results are saved in a json file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['npool', 'z_min', 'z_max', 'size', 'batch_size', 'cosmology', 'snr_finder', 'json_file_names', 'interpolator_directory', 'gw_param_sampler_dict', 'snr_calculator_dict', 'detectable_unlensed_rate_per_year', 'detectability_condition', 'detectable_lensed_rate_per_year', 'rate_ratio'])\n",
      "detectable_unlensed_rate_per_year:  420.30296021631887\n",
      "detectable_lensed_rate_per_year;  1.094440169697147\n",
      "rate_ratio:  384.0346616047772\n"
     ]
    }
   ],
   "source": [
    "from ler.utils import load_json\n",
    "# ler_params = load_json(ler.ler_directory+\"/\"+ler.json_file_names[\"ler_params\"])\n",
    "ler_params = load_json('ler_data/ler_params.json')\n",
    "print(ler_params.keys())\n",
    "print(\"detectable_unlensed_rate_per_year: \", ler_params['detectable_unlensed_rate_per_year'])\n",
    "print(\"detectable_lensed_rate_per_year; \",ler_params['detectable_lensed_rate_per_year'])\n",
    "print(\"rate_ratio: \",ler_params['rate_ratio'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the generated parameters <a class=\"anchor\" id=\"bullet-one-seven\"></a> \n",
    "\n",
    "* Below I plot the generated redshift distributions of the lensed and unlensed populations and comapre them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "getting gw_params from json file ler_data/unlensed_param_detectable.json...\n",
      "getting gw_params from json file ler_data/unlensed_param.json...\n",
      "getting gw_params from json file ler_data/lensed_param_detectable.json...\n",
      "getting gw_params from json file ler_data/lensed_param.json...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# quick plot\n",
    "import matplotlib.pyplot as plt\n",
    "from ler.utils import plots as lerplt\n",
    "\n",
    "# plotting the distribution of event parameters\n",
    "# comparision of redshift distribution for lensed and unlensed events\n",
    "# param_dict can be either a dictionary or a json file name that contains the parameters\n",
    "plt.figure(figsize=(6, 4))\n",
    "# for unlensed case\n",
    "lerplt.param_plot(\n",
    "    param_name='zs',\n",
    "    param_dict='ler_data/unlensed_param_detectable.json',\n",
    "    plot_label='zs (bbh-detectable)',\n",
    "    histogram=False,\n",
    "    kde=True,\n",
    "    kde_bandwidth=0.5,\n",
    ")\n",
    "lerplt.param_plot(\n",
    "    param_name='zs',\n",
    "    param_dict='ler_data/unlensed_param.json',\n",
    "    plot_label='zs (bbh-all)',\n",
    "    histogram=False,\n",
    "    kde=True,\n",
    ")\n",
    "# for lensed case\n",
    "lerplt.param_plot(\n",
    "    param_name='zs',\n",
    "    param_dict='ler_data/lensed_param_detectable.json',\n",
    "    plot_label='zs (bbh-lensed-detectable)',\n",
    "    histogram=False,\n",
    "    kde=True,\n",
    "    kde_bandwidth=0.5,\n",
    ")\n",
    "lerplt.param_plot(\n",
    "    param_name='zs',\n",
    "    param_dict='ler_data/lensed_param.json',\n",
    "    plot_label='zs (bbh-lensed-all)',\n",
    "    histogram=False,\n",
    "    kde=True,\n",
    ")\n",
    "plt.xlim(0.001,8)\n",
    "plt.grid(alpha=0.4)\n",
    "plt.xlabel('Source redshift (zs)')\n",
    "plt.ylabel('Probability Density')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using custom functions and parameters. <a class=\"anchor\" id=\"bullet-two\"></a>\n",
    "\n",
    "\n",
    "* `ler` allows internal model functions to be change with custom functions.\n",
    "\n",
    "* It also allows to change the default parameters of the existing model functions.\n",
    "\n",
    "First let's look at what are the input parameters available for `LeR` class. The input paramters can divided into five categories\n",
    "\n",
    "1. ler.LeR set up params\n",
    "\n",
    "2. ler.CBCSourceParameterDistribution set up params (as kwargs)\n",
    "\n",
    "3. ler.LensGalaxyParameterDistribution set up params (as kwargs)\n",
    "\n",
    "4. ler.ImageProperties set up params (as kwargs)\n",
    "\n",
    "5. gwsnr.GWSNR set up params (as kwargs)\n",
    "\n",
    "Complete LeR initialization is shown below,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # below is the example of LeR initialization with all the arguments.\n",
    "from ler.rates import LeR\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from astropy.cosmology import LambdaCDM\n",
    "\n",
    "# # Uncomment the below code if you need to change the default arguments.\n",
    "# ler = LeR(\n",
    "#     # LeR setup arguments\n",
    "#     npool=4, # number of processors to use\n",
    "#     z_min=0.0, # minimum redshift\n",
    "#     z_max=10.0, # maximum redshift\n",
    "#     event_type='BBH', # event type\n",
    "#     size=100000, # number of events to simulate\n",
    "#     batch_size=50000, # batch size\n",
    "#     cosmology=LambdaCDM(H0=70, Om0=0.3, Ode0=0.7), # cosmology\n",
    "#     snr_finder=None, # snr calculator from 'gwsnr' package will be used\n",
    "#     pdet_finder=None,  # will not be consider unless specified\n",
    "#     list_of_detectors=None, # list of detectors that will be considered when calculating snr or pdet for lensed events. if None, all the detectors from 'gwsnr' will be considered\n",
    "#     json_file_names=dict(\n",
    "#         ler_params=\"ler_params.json\", # to store initialization parameters and important results\n",
    "#         unlensed_param=\"unlensed_param.json\", # to store all unlensed events\n",
    "#         unlensed_param_detectable=\"unlensed_param_detectable.json\", # to store only detectable unlensed events\n",
    "#         lensed_param=\"lensed_param.json\", # to store all lensed events \n",
    "#         lensed_param_detectable=\"lensed_param_detectable.json\"), # to store only detectable lensed events\n",
    "#     interpolator_directory='./interpolator_pickle', # directory to store the interpolator pickle files. 'ler' uses interpolation to get values of various functions to speed up the calculations (relying on numba njit).\n",
    "#     ler_directory='./ler_data', # directory to store all the outputs\n",
    "#     verbose=False, # if True, will print all information at initialization\n",
    "\n",
    "#     # CBCSourceParameterDistribution class arguments\n",
    "#     source_priors= {'merger_rate_density': 'merger_rate_density_bbh_popI_II_oguri2018', 'source_frame_masses': 'binary_masses_BBH_popI_II_powerlaw_gaussian', 'zs': 'sample_source_redshift', 'geocent_time': 'sampler_uniform', 'ra': 'sampler_uniform', 'dec': 'sampler_cosine', 'phase': 'sampler_uniform', 'psi': 'sampler_uniform', 'theta_jn': 'sampler_sine'},\n",
    "#     source_priors_params= {'merger_rate_density': {'R0': 2.39e-08, 'b2': 1.6, 'b3': 2.0, 'b4': 30}, 'source_frame_masses': {'mminbh': 4.98, 'mmaxbh': 112.5, 'alpha': 3.78, 'mu_g': 32.27, 'sigma_g': 3.88, 'lambda_peak': 0.03, 'delta_m': 4.8, 'beta': 0.81}, 'zs': None, 'geocent_time': {'min_': 1238166018, 'max_': 1269702018}, 'ra': {'min_': 0.0, 'max_': 6.283185307179586}, 'dec': None, 'phase': {'min_': 0.0, 'max_': 6.283185307179586}, 'psi': {'min_': 0.0, 'max_': 3.141592653589793}, 'theta_jn': None},\n",
    "#     spin_zero= True, # if True, spins will be set to zero\n",
    "#     spin_precession= False, # if True, spins will be precessing\n",
    "\n",
    "#     # LensGalaxyParameterDistribution class arguments\n",
    "#     lens_type = 'epl_shear_galaxy',\n",
    "#     lens_functions =  {'strong_lensing_condition': 'rjs_with_cross_section_SIE', 'optical_depth': 'optical_depth_SIE_hemanta', 'param_sampler_type': 'sample_all_routine'},\n",
    "#     lens_priors =  {'source_redshift_sl': 'strongly_lensed_source_redshifts', 'lens_redshift': 'lens_redshift_SDSS_catalogue', 'velocity_dispersion': 'velocity_dispersion_ewoud', 'axis_ratio': 'axis_ratio_rayleigh', 'axis_rotation_angle': 'axis_rotation_angle_uniform', 'external_shear': 'shear_norm', 'density_profile_slope': 'density_profile_slope_normal', 'source_parameters': 'sample_gw_parameters'},\n",
    "#     lens_priors_params =  {'source_redshift_sl': None, 'lens_redshift': None, 'velocity_dispersion': None, 'axis_ratio': {'q_min': 0.2, 'q_max': 1.0}, 'axis_rotation_angle': {'phi_min': 0.0, 'phi_max': 6.283185307179586}, 'external_shear': {'scale': 0.05}, 'density_profile_slope': {'mean': 2.0, 'std': 0.2}, 'source_parameters': None},\n",
    "\n",
    "#     # ImageProperties class arguments\n",
    "#     n_min_images = 2,\n",
    "#     n_max_images = 4,\n",
    "#     geocent_time_min = 1126259462.4,\n",
    "#     geocent_time_max = 1756979462.4,\n",
    "#     lens_model_list = ['EPL_NUMBA', 'SHEAR'],\n",
    "\n",
    "#     # gwsnr package arguments\n",
    "#     mtot_min = 2.0,\n",
    "#     mtot_max = 184.98599853446768,\n",
    "#     ratio_min = 0.1,\n",
    "#     ratio_max = 1.0,\n",
    "#     mtot_resolution = 500,\n",
    "#     ratio_resolution = 50,\n",
    "#     sampling_frequency = 2048.0,\n",
    "#     waveform_approximant = 'IMRPhenomD',\n",
    "#     minimum_frequency = 20.0,\n",
    "#     snr_type = 'interpolation',\n",
    "#     psds = {'L1':'aLIGO_O4_high_asd.txt','H1':'aLIGO_O4_high_asd.txt', 'V1':'AdV_asd.txt', 'K1':'KAGRA_design_asd.txt'},\n",
    "#     ifos = ['L1', 'H1', 'V1'],\n",
    "#     interpolator_dir = './interpolator_pickle',\n",
    "#     gwsnr_verbose = False,\n",
    "#     multiprocessing_verbose = True,\n",
    "#     mtot_cut = True,\n",
    "\n",
    "#     # common arguments, to generate interpolator\n",
    "#     create_new_interpolator = dict(\n",
    "#         redshift_distribution=dict(create_new=False, resolution=1000),\n",
    "#         z_to_luminosity_distance=dict(create_new=False, resolution=1000),\n",
    "#         velocity_dispersion=dict(create_new=False, resolution=1000),\n",
    "#         axis_ratio=dict(create_new=False, resolution=1000),\n",
    "#         optical_depth=dict(create_new=False, resolution=200),\n",
    "#         z_to_Dc=dict(create_new=False, resolution=1000),\n",
    "#         Dc_to_z=dict(create_new=False, resolution=1000),\n",
    "#         angular_diameter_distance=dict(create_new=False, resolution=1000),\n",
    "#         differential_comoving_volume=dict(create_new=False, resolution=1000),\n",
    "#         Dl_to_z=dict(create_new=False, resolution=1000),\n",
    "#     )\n",
    "# )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining custom functions and parameters. <a class=\"anchor\" id=\"bullet-two-one\"></a>\n",
    "\n",
    "As an example, I will change,\n",
    "\n",
    "  * **merger_rate_density_params**'s default value of **local merger rate density** ($R_0$) to $38.8\\times 10^{-9} Mpc^{-3} yr^{-1}$ (upper limit of GWTC-3). But, I am still using the default merger_rate_density function, which is `'merger_rate_density_bbh_popI_II_oguri2018'`. Note that the accepted $R_0$ value in [GWTC-3](https://journals.aps.org/prx/pdf/10.1103/PhysRevX.13.011048) is $23.9_{-8.6}^{+14.9}\\times 10^{-9} \\; Mpc^{-3} yr^{-1}$.\n",
    "\n",
    "  * **source_frame_masses** to a custom function. This is similar to the internal default function, i.e. `PowerLaw+Peak model`. I am using `gwcosmo`'s `powerlaw_gaussian` prior for this example.\n",
    "\n",
    "  * **optical depth** for strong lensing condition and **velocity dispersion** of the lensing galaxy to SIS model and gamma function respectively. The default optical depth is that of the SIE model and default velocity dispersion has additional redshift dependence. Note the minimum and maximum values of the velocity dispersion. Default is $[10, 350] \\; km/s$.\n",
    "  \n",
    "  * `gwsnr` parameters: By default, it uses **IMRPhenomD** **waveform model** with no spin. It uses interpolation method to find the 'snr' and it is super fast. But for the example below, I am using **IMRPhenomXPHM** with precessing spins. This is without interpolation but through inner product method, like that of `bilby` but with njit functions and multiprocessing. It will be slower as compare to interpolation method but faster than that of bilby.\n",
    "\n",
    "**Note:** All custom functions sampler should have 'size' as the only input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gwcosmo import priors as p\n",
    "\n",
    "# define your custom function of mass_1_source and mass_2_source calculation\n",
    "# it should have 'size' as the only argument\n",
    "def powerlaw_peak(size):\n",
    "    \"\"\"\n",
    "    Function to sample mass1 and mass2 from a powerlaw with a gaussian peak\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    size : `int`\n",
    "        Number of samples to draw\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    mass_1_source : `numpy.ndarray`\n",
    "        Array of mass1 samples\n",
    "    mass_2_source : `numpy.ndarray`\n",
    "        Array of mass2 samples\n",
    "    \"\"\"\n",
    "\n",
    "\n",
    "    # below is the gwcosmo default values\n",
    "    mminbh=4.98  # Minimum mass of the black hole (Msun)\n",
    "    mmaxbh=86.22  # Maximum mass of the black hole (Msun) \n",
    "    alpha=2.63  # Spectral index for the powerlaw of the primary mass distribution\n",
    "    mu_g=33.07  # Mean of the Gaussian component in the primary mass distribution\n",
    "    sigma_g=5.69  # Width of the Gaussian component in the primary mass distribution\n",
    "    lambda_peak=0.10  # Fraction of the model in the Gaussian component\n",
    "    delta_m=4.82  # Range of mass tapering on the lower end of the mass distribution\n",
    "    beta=1.26  # Spectral index for the powerlaw of the mass ratio distribution\n",
    "\n",
    "    model = p.BBH_powerlaw_gaussian(\n",
    "        mminbh=mminbh,\n",
    "        mmaxbh=mmaxbh,\n",
    "        alpha=alpha,\n",
    "        mu_g=mu_g,\n",
    "        sigma_g=sigma_g,\n",
    "        lambda_peak=lambda_peak,\n",
    "        delta_m=delta_m,\n",
    "        beta=beta,\n",
    "    )\n",
    "    # sample mass1 and mass2\n",
    "    mass_1_source, mass_2_source = model.sample(Nsample=size)\n",
    "\n",
    "    return (mass_1_source, mass_2_source)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LeR initialization with custom functions and parameters <a class=\"anchor\" id=\"bullet-two-two\"></a>\n",
    "\n",
    "* Initialize the class with the custom function\n",
    "\n",
    "* changing ler input params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ler.rates import LeR\n",
    "import numpy as np\n",
    "\n",
    "ler = LeR(npool=4, verbose=False,\n",
    "    # for source parameters  \n",
    "    source_priors=dict(\n",
    "        merger_rate_density='merger_rate_density_bbh_popI_II_oguri2018',\n",
    "        source_frame_masses=powerlaw_peak,\n",
    "    ),\n",
    "    source_priors_params=dict(\n",
    "        merger_rate_density=dict(\n",
    "            R0=38.8e-09,\n",
    "            b2=1.6,\n",
    "            b3=2.0,\n",
    "            b4=30\n",
    "        ),\n",
    "        source_frame_masses=None,\n",
    "    ),\n",
    "    # for lens parameters\n",
    "    lens_functions=dict(\n",
    "        strong_lensing_condition=\"rjs_with_cross_section_SIS\",\n",
    "        optical_depth=\"optical_depth_SIS_haris\",\n",
    "    ),\n",
    "    lens_priors=dict(\n",
    "        velocity_dispersion=\"velocity_dispersion_gengamma\",\n",
    "    ),\n",
    "    lens_priors_params=dict(\n",
    "        velocity_dispersion=dict(a=2.32 / 2.67, c=2.67)\n",
    "    ),\n",
    "    # for snr generation\n",
    "    waveform_approximant = 'IMRPhenomXPHM',\n",
    "    snr_type='inner_product',\n",
    "    spin_zero=False,\n",
    "    spin_precession=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* since I am using inner product to calculate snr, it will take longer time to simulate the events.\n",
    "\n",
    "* You can increase the speed by allocating more CPU cores to the code. For example, if you have 8 logical cores, set npool>4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sampling (Unlensed). <a class=\"anchor\" id=\"bullet-two-three\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed params will be store in ./ler_data/new_unlensed_params.json\n",
      "chosen batch size = 25000 with total size = 50000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling gw source params...\n",
      "calculating snrs...\n",
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████| 20250/20250 [00:51<00:00, 396.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch no. 2\n",
      "sampling gw source params...\n",
      "calculating snrs...\n",
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|████████████████████████████████████████████████████████| 20344/20344 [00:51<00:00, 391.53it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saving all unlensed parameters in ./ler_data/new_unlensed_params.json \n"
     ]
    }
   ],
   "source": [
    "ler.batch_size = 25000\n",
    "# increase size for accurate rate calculation\n",
    "# for Apple silicon M2 pro 16GB RAM, npool=4, time taken is 1m 44.8s\n",
    "ler.unlensed_cbc_statistics(size=50000, resume=False, output_jsonfile = 'new_unlensed_params.json');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sampling (Lensed). <a class=\"anchor\" id=\"bullet-two-four\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lensed params will be store in ./ler_data/new_lensed_params.json\n",
      "chosen batch size = 25000 with total size = 50000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling lensed params...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 25000/25000 [00:06<00:00, 3965.92it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid sample found. Resampling 1 lensed events...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 11.49it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n",
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|████████████████████████████████████████████████████████| 18026/18026 [00:46<00:00, 391.77it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████| 18026/18026 [00:43<00:00, 410.05it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 2600/2600 [00:06<00:00, 410.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████████████████████████████████████████████████████| 2201/2201 [00:05<00:00, 405.64it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch no. 2\n",
      "sampling lensed params...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 25000/25000 [00:05<00:00, 4262.94it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid sample found. Resampling 2 lensed events...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 24.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n",
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|████████████████████████████████████████████████████████| 18070/18070 [00:43<00:00, 412.07it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████| 18070/18070 [00:44<00:00, 409.45it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 2566/2566 [00:06<00:00, 414.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████████████████████████████████████████████████████| 2184/2184 [00:05<00:00, 413.02it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saving all lensed parameters in ./ler_data/new_lensed_params.json \n"
     ]
    }
   ],
   "source": [
    "# increase the size if you need accurate rate calculation\n",
    "# for Apple silicon M2 pro 16GB RAM, npool=4, time taken is \n",
    "ler.lensed_cbc_statistics(size=50000, resume=False, output_jsonfile = 'new_lensed_params.json');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* generate detectable events and compute the rate ratio\n",
    "\n",
    "* note: here no input params are provided, so it will track the json files generated above\n",
    "\n",
    "* For individual rate computation, use\n",
    "    ```ler.unlensed_rate();```\n",
    "    ```ler.lensed_rate();```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rate calculation and comparison. <a class=\"anchor\" id=\"bullet-two-five\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting unlensed_param from json file ./ler_data/new_unlensed_params.json...\n",
      "given detectability_condition == 'step_function'\n",
      "total unlensed rate (yr^-1): 1522.6442174796687\n",
      "number of simulated unlensed detectable events: 453\n",
      "number of simulated all unlensed events: 50000\n",
      "storing detectable params in ./ler_data/new_unlensed_params_detectable.json\n",
      "Getting lensed_param from json file ./ler_data/new_lensed_params.json...\n",
      "given detectability_condition == step_function\n",
      "total lensed rate (yr^-1): 1.1059902347300807\n",
      "number of simulated lensed detectable events: 337\n",
      "number of simulated all lensed events: 50000\n",
      "storing detectable params in ./ler_data/new_lensed_params_detectable.json\n",
      "unlensed_rate: 1522.6442174796687\n",
      "lensed_rate: 1.1059902347300807\n",
      "ratio: 1376.7248296286027\n"
     ]
    }
   ],
   "source": [
    "# you might not need to provide the json file names\n",
    "# at the end of each sampling, the json file names will be updated in the ler_params.json file. The default json file names are call from the ler_params.json file.\n",
    "rate_ratio, unlensed_param_detectable, lensed_param_detectable =ler.rate_comparison_with_rate_calculation(\n",
    "    unlensed_param='new_unlensed_params.json',\n",
    "    snr_threshold_unlensed=8.0,\n",
    "    lensed_param='new_lensed_params.json',\n",
    "    output_jsonfile_unlensed='new_unlensed_params_detectable.json',\n",
    "    output_jsonfile_lensed='new_lensed_params_detectable.json',\n",
    "    snr_threshold_lensed=[8.0,8.0],\n",
    "    num_img=[1,1],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important Note:**\n",
    "* input parameters, snr_threshold_lensed=[8.0,8.0], num_img=[1,1], means that two of the images should have snr>8.0. You can also set: snr_threshold_lensed=8, num_img=2\n",
    "\n",
    "* Similarly, if snr_threshold_lensed=[8.0,6.0], num_img=[2,2], it means that two of the images should have snr>8.0 and other two images should have snr>6.0. But in this case, even though the simulated lensed (detectable) events are correct, the rate calculation will not be right as the strong lensing condition was set for 2 image case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uning available model functions <a class=\"anchor\" id=\"bullet-three\"></a>\n",
    "\n",
    "How to look for available model functions?\n",
    "\n",
    "* All available names are stored as a dict in `ler` instance\n",
    "\n",
    "* the keys of this dict shows the parameter type\n",
    "\n",
    "* the values are also dict, where the keys are the model function names and the values are their input parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'binary_masses_BBH_popI_II_powerlaw_gaussian': {'mminbh': 4.98, 'mmaxbh': 112.5, 'alpha': 3.78, 'mu_g': 32.27, 'sigma_g': 3.88, 'lambda_peak': 0.03, 'delta_m': 4.8, 'beta': 0.81}, 'binary_masses_BBH_popIII_lognormal': {'Mc': 30.0, 'sigma': 0.3, 'beta': 1.1}, 'binary_masses_BBH_primordial_lognormal': {'Mc': 30.0, 'sigma': 0.3, 'beta': 1.1}, 'binary_masses_BNS_gwcosmo': {'mminns': 1.0, 'mmaxns': 3.0, 'alphans': 0.0}, 'binary_masses_BNS_bimodal': {'w': 0.643, 'muL': 1.352, 'sigmaL': 0.08, 'muR': 1.88, 'sigmaR': 0.3, 'mmin': 1.0, 'mmax': 2.3}}\n",
      "{'velocity_dispersion_haris': {'a': 0.8689138576779026, 'c': 2.67}, 'velocity_dispersion_gengamma': {'a': 0.8689138576779026, 'c': 2.67}, 'velocity_dispersion_bernardi': None, 'velocity_dispersion_ewoud': None}\n"
     ]
    }
   ],
   "source": [
    "# for unlensed case\n",
    "print(ler.available_gw_prior_list_and_its_params['source_frame_masses'])\n",
    "# for lensed case\n",
    "print(ler.available_lens_prior_list_and_its_params['velocity_dispersion'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* for looking at the choosen models and its input parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'merger_rate_density': 'merger_rate_density_bbh_popI_II_oguri2018', 'source_frame_masses': <function powerlaw_peak at 0x32f3ffd90>, 'zs': 'sample_source_redshift', 'geocent_time': 'sampler_uniform', 'ra': 'sampler_uniform', 'dec': 'sampler_cosine', 'phase': 'sampler_uniform', 'psi': 'sampler_uniform', 'theta_jn': 'sampler_sine', 'a_1': 'sampler_uniform', 'a_2': 'sampler_uniform', 'tilt_1': 'sampler_sine', 'tilt_2': 'sampler_sine', 'phi_12': 'sampler_uniform', 'phi_jl': 'sampler_uniform'}\n",
      "{'merger_rate_density': {'R0': 3.88e-08, 'b2': 1.6, 'b3': 2.0, 'b4': 30}, 'source_frame_masses': None, 'zs': None, 'geocent_time': {'min_': 1238166018, 'max_': 1269702018}, 'ra': {'min_': 0.0, 'max_': 6.283185307179586}, 'dec': None, 'phase': {'min_': 0.0, 'max_': 6.283185307179586}, 'psi': {'min_': 0.0, 'max_': 3.141592653589793}, 'theta_jn': None, 'a_1': {'min_': 0.0, 'max_': 0.8}, 'a_2': {'min_': 0.0, 'max_': 0.8}, 'tilt_1': None, 'tilt_2': None, 'phi_12': {'min_': 0, 'max_': 6.283185307179586}, 'phi_jl': {'min_': 0, 'max_': 6.283185307179586}}\n",
      "{'source_redshift_sl': 'strongly_lensed_source_redshifts', 'lens_redshift': 'lens_redshift_SDSS_catalogue', 'velocity_dispersion': 'velocity_dispersion_gengamma', 'axis_ratio': 'axis_ratio_rayleigh', 'axis_rotation_angle': 'axis_rotation_angle_uniform', 'external_shear': 'shear_norm', 'density_profile_slope': 'density_profile_slope_normal', 'source_parameters': 'sample_gw_parameters'}\n",
      "{'source_redshift_sl': None, 'lens_redshift': None, 'velocity_dispersion': {'a': 0.8689138576779026, 'c': 2.67}, 'axis_ratio': {'q_min': 0.2, 'q_max': 1.0}, 'axis_rotation_angle': {'phi_min': 0.0, 'phi_max': 6.283185307179586}, 'external_shear': {'scale': 0.05}, 'density_profile_slope': {'mean': 2.0, 'std': 0.2}, 'source_parameters': None}\n"
     ]
    }
   ],
   "source": [
    "# for unlensed case\n",
    "print(ler.gw_param_samplers)\n",
    "print(ler.gw_param_samplers_params)\n",
    "# for lensed case\n",
    "print(ler.lens_param_samplers)\n",
    "print(ler.lens_param_samplers_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison of mass distribution model (BBH, mass-1, larger mass only). <a class=\"anchor\" id=\"bullet-three-one\"></a>\n",
    "\n",
    "* compare the default mass distribution with the custom mass distribution function defined on the previous example [link](###bullet-two-one). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calling the default mass distribution model\n",
    "mass_1_source, mass_2_source = ler.binary_masses_BBH_popI_II_powerlaw_gaussian(size=10000)\n",
    "default_model_dict = dict(mass_1_source=mass_1_source)\n",
    "\n",
    "# calling the custom mass distribution model\n",
    "mass_1_source, mass_2_source = powerlaw_peak(size=10000)\n",
    "custom_model_dict = dict(mass_1_source=mass_1_source)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAF1CAYAAAAk3Np1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACUrElEQVR4nOzdd3gU1frA8e9sy6Y3SCUFQgu9I02wBguCDS56RRSx/ETkgqixgF4LiqKgqNyrV8CCoKKgSBEQUOnSREINCaGkAeltk935/bHJQkwI2c2mkffzPPPs7uyZmXdPAvvmzCmKqqoqQgghhBANnKa+AxBCCCGEqA5JWoQQQgjRKEjSIoQQQohGQZIWIYQQQjQKkrQIIYQQolGQpEUIIYQQjYIkLUIIIYRoFHT1HUBjYLFYOHPmDJ6eniiKUt/hCCGEEI2Gqqrk5OQQEhKCRlOzthJJWqrhzJkzhIWF1XcYQgghRKN18uRJWrRoUaNzSNJSDZ6engCcOHECHx+f+g2mEbFYLJw8eZKwsLAaZ9dNhdSZY6Te7Cd15hipN/tlZmYSERFh+y6tCUlaqqHslpCXlxdeXl71HE3jYbFY8PT0xMvLS/5xV5PUmWOk3uwndeYYqTf7WSwWAKd0r5AaF0IIIUSjIEmLEEIIIRoFSVqEEEII0ShInxYhhGgALBYLJpOpTq9nNpspLCyUvhl2kHqrSK/Xo9Vq6+RakrQIIUQ9M5lMJCQk2Dos1gVVVTGbzSQmJsr8U3aQequcj48PQUFBtV4nkrQIIUQ9UlWV5ORktFptnQ6jVVWV4uJi9Hq9fPnaQeqtPFVVyc/PJy0tDYDg4OBavZ4kLUIIUY9KSkrIz88nJCQENze3OruuqqpoNBoMBoN8+dpB6q0iV1dXANLS0ggICKjVW0VyQ04IIeqR2WwGwGAw1HMkQjiuLOEuLi6u1etI0iKEEA2A/NUuGrO6+v2VpEUIIYQQjYL0aRFCiAbodGYBGXm1NwT67x1Kfd0NhPq41tr1hHAGSVquUMm5yWQUZdTJtXxdfAn2qN0e40I0JaczC7h+1iYKis11dk1XvZZ1UwZL4lLHFixYwKRJk8jMzKz2MYqi8P333zNixIhai6uhkqTlCpScm8zw5cMpKCmok+u56lxZPny5JC5COElGnomCYjOzR3WjdYBHrVzj4paW+PQ8Ji3ZS0aeqUEkLRs3buSaa64hIyMDHx+f+g5HNCCStFyBMooyKCgpYMagGbTyblWr1zqedZzY32LJKMqQpEUIJ2sd4EGnUO9aObeqqphMJhm6KxoV6Yh7BWvl3YoO/h2ctkV7t6XVOR1tCbTtq+2kSAjRMFksFmbOnEnr1q1xcXEhPDyc1157DbC2lCiKUu6Wx969e1EUhcTERABOnDjBsGHD8PX1xd3dnY4dO7Jy5UoSExO55pprAPD19UVRFMaOHQtAUVEREydOJCAgAKPRyMCBA9m5c6ftGmXXXbNmDd27d8fV1ZVrr72WtLQ0Vq1aRXR0NF5eXtxzzz3k5+df8rMtWLAAHx8fVqxYQbt27XBzc+Ouu+4iPz+fhQsX0rZtW/z8/Jg4caJtyDpARkYGY8aMwdfXFzc3N2666SaOHj1a4dzh4eG4ublx++23c+7cuQrXX758OT169MBoNNKqVStefvllSkpK7Pr5XKmkpUVUi+nECU5NeIKio0dBq6X5ExNo9uij9R2WEKKexMbG8vHHH/Puu+8ycOBAkpOTOXToULWPf/zxxzGZTPz666+4u7sTFxeHh4cHYWFhLF26lDvvvJPDhw/j5eVlm7zs6aefZunSpSxcuJCIiAhmzpxJTEwMx44dw8/Pz3bul156iblz5+Lm5sbIkSMZOXIkLi4uLFq0iNzcXG6//Xbef/99nnnmmUvGl5+fz3vvvcfixYvJycnhjjvu4Pbbb8fHx4fly5dz8uRJ7rrrLgYMGMCoUaMAGDt2LEePHuWHH37Ay8uLZ555hptvvpm4uDj0ej3bt29n3LhxzJgxgxEjRrB69WqmT59e7rq//fYbY8aM4b333mPQoEHEx8fz8MMPA1Qo2ySp4rKysrJUQM3IyKjvUKrlwNkDaqcFndQDZw845Xzm/Hz12C23qHHt2pfbMr79tsprmc1mNSEhQTWbzU6JoymQOnNMY663goICNS4uTi0oKLDt238qU414ZoW6/1RmrV3XYrGohYWFqsVisft62dnZqouLi/rxxx9X+v6GDRsq/J+5Z88eFVATEhJUVVXVzp07qy+99FK1j8/NzVX1er365Zdf2vaZTCY1JCREnTlzZrnj1q1bZyszY8YMFVDj4+Nt+x555BE1Jibmkp9v/vz5KqAeO3as3DFubm5qdna2rd5iYmLURx55RFVVVT1y5IgKqJs3b7Ydc/bsWdXV1VX9+uuvVVVV1dGjR6s333xzuWuNGjVK9fb2tr2+7rrr1Ndff71cmc8//1wNDg62vQbU77///pLx14fKfo/LZGRkqICalZVV4+s0uNtDH3zwAZGRkRiNRvr27cuOHTsuWfbAgQPceeedREZGoigKs2fPrlBmxowZ9O7dG09PTwICAhgxYgSHDx+uxU9w5Tn/2eeYjsWja96c1ps20mzCBABSX58BWTn1HJ0Qoq4dPHiQoqIirrvuOofPMXHiRF599VUGDBjA9OnT+fPPP6ssHx8fT3FxMQMGDLDt0+v19OnTh4MHD5Yr26VLF9vzwMBA3NzcaNWqVbl9ZWvlXIqbmxtRUVHljomMjMTDw6PcvrLzHDx4EJ1OR9++fW3v+/v7065dO1t8Bw8eLPc+QL9+/cq93rdvH//+97/x8PCwbePHjyc5ObnKW1pNRYNKWpYsWcLkyZOZPn06u3fvpmvXrsTExFzylys/P59WrVrxxhtvEBQUVGmZTZs28fjjj7Nt2zbWrl1LcXExN954I3l5ebX5Ua4Ylvx8zn/6KQABU59CHxhIs/97DJf27bHk5cGi5fUcoRCirpXdrrmUskUfVVW17fv79O4PPfQQx48f57777mP//v306tWL999/3ynx6fV623NFUcq9Ltt3uRW1KzvGkfPYKzc3l5dffpm9e/fatv3793P06FGMRqNTr9UYNaik5Z133mH8+PE88MADdOjQgXnz5uHm5sanpV+af9e7d2/eeust/vGPf+Di4lJpmdWrVzN27Fg6duxI165dWbBgAUlJSezatas2P8oVI/vnnzFnZaEPC8PrllsAUDQamj9hbW3hh7XoS9QqziCEuNK0adMGV1dX1q9fX+n7zZs3ByA5Odm2b+/evRXKhYWF8eijj/Ldd98xZcoUPv74Y+DCOkwXd3KNiorCYDCwefNm277i4mJ27txJhw4davyZaio6OpqSkhK2b99u23fu3DkOHz5siy86Orrc+wDbtm0r97pHjx4cPnyY1q1bV9jqagXwhqzBdMQ1mUzs2rWL2NhY2z6NRsP111/P1q1bnXadrKwsgHKdtv6uqKiIoqIi2+vs7GzA2lve2Vl1bVAtqu2xpvFmfvcdAN63j0BVFNTS87ldfTW64GBKkpO56pCm0muV1VdjqLOGQurMMY253iwWC6qq2ja40EJxNDWnXGuFs5XN03IsLdd23epcz8XFhaeffpqnn34avV7PgAEDSE9P58CBA4wbN46oqCjCwsJ46aWXePXVVzly5AizZs0qd41JkyZx00030bZtWzIyMtiwYQPR0dGoqkp4eDiKovDjjz9y88034+rqioeHB48++ihTp07F19eX8PBw3nrrLfLz83nwwQcr1N/f6/Liz1XZvotVdcylyrdu3Zrhw4czfvx45s2bh6enJ7GxsYSGhnLbbbehqipPPPEEAwcO5K233mL48OGsWbOG1atXlzv/iy++yLBhwwgLC+Ouu+5Co9Gwb98+/vrrL1599dVy16zN3w17lcVT2b9DZ/67bDBJy9mzZzGbzQQGBpbbHxgYaFeP9KpYLBYmTZrEgAED6NSp0yXLzZgxg5dffrnC/lOnTtkSmIYsOcf6101ySjLuee4On0fNzKRw5x8A5PTsSV5SUvkC114LX37JgDi10mupqkpGRgaKosg8ENUkdeaYxlxvZrMZs9lMcXGx7S9pD72Cq17Dv77eV2dxuOo1eOgVTKbqLR3wzDPPoCgK06ZNIzk5maCgIMaPH287fuHChUycOJGuXbvSs2dPpk+fzj333IPJZMJkMlFcXMzjjz/O6dOn8fLy4oYbbuCtt97CZDLRvHlzXnzxRWJjY3nwwQe59957+eSTT/j3v/9NSUkJY8aMIScnhx49evDjjz/i7u5uOydguwZgGyp88ecym822eWoqc7ljyt43m81YLBZbuXnz5jFlyhSGDRuGyWRi4MCBLFu2zHZcjx49+PDDD3nllVeYPn061157Lc8++ywzZsywneOaa67h+++/57XXXmPmzJno9XratWvH2LFjy8VTUlJS7Z9VXSguLsZsNpOcnIxWqy33njO/NxW1gaRqZ86cITQ0lC1btpTrmPT000+zadOmCk1qfxcZGcmkSZOYNGnSJcs89thjrFq1it9//50WLVpcslxlLS1hYWGcO3euUczOePDcQf6x8h8svnkx0f7RDp8na9kyUp57HpfoaCKXflvh/aL4eBKH3UaJBjQrFhId2avc+xaLhaSkJMLDw6VZs5qkzhzTmOutsLCQxMREWrZsWa7PQm2vPQQXWloAWXvIDmWT8okLCgsLSUhIsA2kuVhmZib+/v5kZWXh5eVVo+s0mJaWZs2aodVqSU1NLbc/NTX1kp1s7TFhwgRWrFjBr7/+WmXCAtamz8r6yGg0mkbxH6KiUWyPNYk3b9OvAHhec02l53Ft0wa1ZRi6hJOo2/egadWnQpmyOmsM9dZQSJ05prHWm0ajsbUQXdxK1MLXjRa+brV23bK//mVGXPtc/He+1NsFZb+/lf0bdOa/yQbzr9tgMNCzZ89yHbssFgvr16+vMCTMHqqqMmHCBL7//nt++eUXWrZs6Yxwr3iqxUJ+aeuW+8CBly7Yr4f18Y+qhysKIYQQNdVgWloAJk+ezP3330+vXr3o06cPs2fPJi8vjwceeACAMWPGEBoayowZMwBrE11cXJzt+enTp9m7dy8eHh60bt0asM66uGjRIpYvX46npycpKSkAeHt7X3bYXlNWdPQY5sxMFDc3XDtfuv8PvbpYhz3/8SeqqspfHkIIIWpNg0paRo0aRXp6OtOmTSMlJYVu3bqxevVqW+fcpKSkcs1MZ86coXv37rbXb7/9Nm+//TaDBw9m48aNAHz00UcADBkypNy15s+fb1vPQlSUXzqpn1uPHih/m5ugnK7RFGtBn3oWU2IiLtKSJYQQopY0qKQFrH1PJpTOuPp3ZYlImcjIyMsO+Wog/YwbnYJ91lELbj17VF3Q6MLhFgqdTqjkbd0qSYsQQoha02D6tIiGpfCvvwAwdup82bL7I6y3hPKdOJ+OEEII8XeStIgKzDk5mEqXjzd26njZ8vsjrUlL3vYdtsnnhBBCCGeTpEVUUBhnXdxLHxKCztf3suUTgkB1MWDJzrYlO0IIIYSzSdIiKrDdGup4+VYWALNWgXbWFVQL9snQZyGEqK4FCxbYPWmpoigsW7bsku8PGTKkyolWKzN27FhGjBhh1zH1QZIWUUHhgQMAGKtY6qCCDm0AKPiz7qYdF0JcmTZu3IiiKGRmZtZ3KKKBkaRFVFBwwL6WFsCWtBRKS4sQQohaIkmLKMecnU3xCevCiMaOdiz33rE0aTlyBEthYW2EJoRoQCwWCzNnzqR169a4uLgQHh7Oa6+9BlTeUrJ3714URSGxtN/biRMnGDZsGL6+vri7u9OxY0dWrlxJYmIi11xzDQC+vr4oimKbU6uoqIiJEycSEBCA0Whk4MCB7Ny503aNsuuuWbOG7t274+rqyrXXXktaWhqrVq0iOjoaLy8v7rnnHvLz8y/52cpu2axYsYJ27drh5ubGXXfdRX5+PgsXLqRt27b4+fkxceJEzGaz7biMjAzGjBmDr68vbm5u3HTTTRw9erTCucPDw3Fzc+P222/n3LlzFa6/fPlyevTogdFopFWrVrz88su2RRod8dNPP+Ht7c2XX34JWBd6nDx5Mj4+Pvj7+/P0009XmB7EYrEwY8YMWrZsiaurK127duXbbyuuQVfXGtw8LaJ+FR05AoAuOLhanXBtApujbdYM89mzFMbF4dbjMvO7CCEqp6pQfOkvVKdex2QCiqFsJmu924XnlxEbG8vHH3/Mu+++y8CBA0lOTubQoUPVvvzjjz+OyWTi119/xd3dnbi4ODw8PAgLC2Pp0qXceeedHD58GC8vL9vs5U8//TRLly5l4cKFREREMHPmTGJiYjh27Bh+fn62c7/00kvMnTsXNzc3Ro4cyciRI3FxcWHRokXk5uZy++238/777/PMM89cMr78/Hzee+89Fi9eTE5ODnfccQe33347Pj4+LF++nJMnT3LXXXcxYMAARo0aBVj7hRw9epQffvgBLy8vnnnmGW6++Wbi4uLQ6/Vs376dcePGMWPGDEaMGMHq1auZPn16uev+9ttvjBkzhvfee49BgwYRHx/Pww8/DFChbHUsWrSIRx99lEWLFnHrrbcCMGvWLBYsWMCnn35KdHQ0s2bN4vvvv+faa6+1HTdjxgy++OIL5s2bR5s2bfj111/55z//SfPmzRk8eLDdcTiLJC2inKL44wC4lC6DUG2KgmuXLuT+8gsF+/6UpEUIRxXnw+shtX4ZBaiwLOxzZ8Dgftljc3JymDNnDnPnzuX+++8HICoqioFVrVP2N0lJSdx555107mydC6pVq1a298oSkICAAFsn1by8PD766CMWLFjATTfdBMDHH3/M2rVr+d///sfUqVNtx7/66qsMGDAAgHHjxhEbG0t8fLztGnfddRcbNmyoMmkpLi7mo48+IioqynbM559/TkpKCgaDga5du3LNNdewYcMGRo0aZUtWNm/eTP/+/QH48ssvCQsLY9myZdx9993MmTOHoUOH8vTTTwPQtm1btmzZwurVq23Xffnll3n22Wdt9dqqVSteeeUVnn76abuTlg8++IDnn3+eH3/8sVyiMXv2bGJjY7njjjsAmDdvHmvWrLG9X1RUxOuvv866detsa/+1atWK33//nf/85z+StIiGw3Q8HgCXi/4Dqa6ypKVs9JEQ4sp08OBBioqKuO666xw+x8SJE3nsscf4+eefuf7667nzzjvp0qXLJcvHx8dTXFxsS0YA9Ho9ffr04eDBg+XKXnyewMBA3NzcyiVFgYGB7ChdquRS3NzcbAlL2TGRkZF4eHhgMpls+9LS0gBrneh0Ovr27Ws7xt/fn3bt2tniO3jwILfffnu56/Tr169c0rJv3z42b95su9UG1ts5hYWF5Ofn4+ZWvZW/v/32W9LS0ti8eTO9e/e27c/KyiI5OblcnDqdjl69etluER07doz8/HxuuOGGcuc0mUzlls6pD5K0iHLKWloMUfYnLcbo9gAUHq5+E7EQ4m/0btYWj1qmqiomkwmDwXBhoVN99b4QL7fYbNkacRf3kyguLi5X5qGHHiImJoaffvqJn3/+mRkzZjBr1iyeeOIJOz5F5fQXrZemKEq512X7LJeZCLOyYxw5j71yc3N5+eWXba0gFzMajdU+T/fu3dm9ezeffvopvXr1smsx29zcXMDaFyY0NLTcey4uFdrn6pR0xBXlFJW1tFz0F0Z1ubSPBsB0PEE64wrhKEWx3qKpj62aX2xt2rTB1dWV9evXV/p+8+bNAUhOTrbt27t3b4VyYWFhPProo3z33XdMmTKFjz/+GACDwQBQrpNrVFQUBoOBzZs32/YVFxezc+dOOnSwY9BALYmOjqakpITt27fb9p07d47Dhw/b4ouOji73PsC2bdvKve7RoweHDx+mdevWFbaLFwy+nKioKDZs2MDy5cvLJYLe3t4EBweXi6OkpIRdu3bZXnfo0AEXFxeSkpIqxBAWFlbtGGqDtLQIG0teHiVnrP/JGBy4PaQLaI7W1xdzRgZFR4/hYs/oIyFEo2E0GnnmmWd4+umnMRgMDBgwgPT0dA4cOMC4ceNsX24vvfQSr732GkeOHGHWrFnlzjFp0iRuuukm2rZtS0ZGBhs2bCA62vqHT0REBIqisGLFCm6++WZcXV3x8PDgscceY+rUqfj5+REeHs7MmTPJz89n3Lhx9VEN5bRp04bhw4czfvx4/vOf/+Dp6cmzzz5LaGgow4cPB6y3xAYMGMDbb7/N8OHDWbNmTblbQwDTpk3j1ltvJTw8nLvuuguNRsO+ffv466+/ePXVV+2KqW3btmzYsIEhQ4ag0+mYPXs2AE8++SRvvPEGbdq0oX379rzzzjvlRnp5enry1FNP8a9//QuLxcLAgQPJyspi8+bNeHl52frb1AdpaRE2RQmJAGj9/OwbOVRKUZQLt4gOHbxMaSFEY/biiy8yZcoUpk2bRnR0NKNGjbL179Dr9Xz11VccOnSILl268Oabb1b4wjWbzTz++ONER0czdOhQ2rZty4cffghAaGiorUNqYGAgEyZMAOCNN97gzjvv5L777qNHjx4cO3aMNWvW4OvA/1e1Yf78+fTs2ZNbb72Vfv36oaoqK1eutN1Wuuqqq/j444+ZM2cOXbt25eeff+aFF14od46YmBhWrFjBzz//TO/evbnqqqt49913iYiIcCimdu3a8csvv/DVV18xZcoUAKZMmcJ9993H/fffT79+/fD09KzQ1+aVV17hxRdfZMaMGbaf0U8//UTLli0disNZFPXvg7NFBdnZ2Xh7e5ORkWH3dMv1Ie5cHKNWjGLJrUvo4F/91o6sH37gzNPP4NarFxFffO7QtVLfnMn5+fPxvfdeAp5/jqSkJMLDw+1q1mzKLBaL1JkDGnO9FRYWkpCQQMuWLe3qs1BTlfZpEZcl9Va5qn6PMzMz8fX1JSsrCy8vrxpdp3H96xa1quiYtT+LwYH+LGWM7dsBUGjHfA1CCCFEdUjSImwudMK1vz9LmbLOuEWHDqE6uVe9EEKIpk2SFmFjKp1e29CyBklLq5Yoej2WvDyKT592UmRCCCGEJC2ilGqxUHzyFACGiHCHz6Po9bbbS6a/rbkhhBBC1IQkLQKAkvR01KIi0GrRBwfX6FxlSwAUxcc7IzQhhBACkKRFlCpOsq7srA8ORvnbrI/2cmld2tJSOruuEEII4QyStAgATEknATCE13y2w7LbQ9LSIoQQwpkkaREAmE5ZkxZ9mOP9Wcq4RFlvD5mOH5cRREIIIZxGkhYBQLEzW1rCw0CvRy0oQE1Lr/H5hBBCCJC1h0Qp08mylpaaJy2KTodLZCRFR4+iJp2APr0vf5AQopzk3GQyijJq7fyqqlJSXIJOr0NRFHxdfAn2qFkn/CFDhtCtWzfbGjfVsWzZMp566ikSEhJ44okn7Dq2Koqi8P333zNixAinnM/ZNm7cyDXXXGPXTOuRkZFMmjSJSZMm1WpsDZkkLQK40BHXEF7z20MAhtZRFB09iqX0vEKI6kvOTWb48uEUlBTU2TVdda4sH768xomLvR555BEeeOABJk6ciKenZ61cIzExkZYtW7Jnzx66detWK9cQdUOSFoE5Jwdz6Qqf+hbOWXbcJao1OYBaettJCFF9GUUZFJQUMGPQDFp5Oz7ZY1UubmlJyE4g9rdYMooy6jRpyc3NJS0tjZiYGEJCQursuqLxkj4tguLSW0NaPz+0Hu5OOWfZsGdpaRHCca28W9HBv0Otbe392tPBv4NDiVFeXh5jxozBw8OD4OBgZs2aVaFMUVERTz31FKGhobi7u9O3b182btwIWG+PlLWsXHvttSiKwsaNGzl37hyjR48mNDQUNzc3OnfuzFdffVXuvJGRkRVuI3Xr1o2XXnqp0ljLVibu3r07iqIwZMiQSstt3LgRRVFYs2YN3bt3x9XVlWuvvZa0tDRWrVpFdHQ03t7ejBkzhvz8/HKfc+LEiQQEBGA0Ghk4cCA7d+4sd+6VK1fStm1bXF1dueaaa0gsnYH8Yr///juDBg3C1dWVsLAwJk6cSF5eXqWxNlWStIgLw52d0J+ljEvpsGc1KQlZSFyIK8/UqVPZtGkTy5cv5+eff2bjxo3s3r27XJkJEyawdetWFi9ezJ9//sndd9/N0KFDOXr0KP379+fw4cMALF26lOTkZPr3709hYSE9e/bkp59+4q+//uLhhx/mvvvuY8eOHQ7HWnbsunXrSE5O5rvvvquy/EsvvcTcuXPZsmULJ0+eZOTIkcyePZtFixaxYsUK1q9fz/vvv28r//TTT7N06VIWLlzI7t27ad26NTExMZw/fx6AkydPcscddzBs2DD27t3LQw89xLPPPlvumvHx8QwdOpQ777yTP//8kyVLlvD7778zYcIEhz/3lUiSFkHxaev0/c7ohFvGEBEBWi3k51OSlua08woh6l9ubi7/+9//ePvtt7nuuuvo3LkzCxcupKSkxFYmKSmJ+fPn88033zBo0CCioqJ46qmnGDhwIPPnz8dgMBAQEACAn58fQUFBGAwGQkNDeeqpp+jWrRutWrXiiSeeYOjQoXz99dcOx9u8eXMA/P39CQoKws/Pr8ryr776KgMGDKB79+6MGzeOTZs28dFHH9G9e3cGDRrE7bffbmsxysvL46OPPuKtt97ipptuokOHDnz88ce4urryv//9D4CPPvqIqKgoZs2aRbt27bj33nsZO3ZsuWvOmDGDe++9l0mTJtGmTRv69+/Pe++9x2effUZhYaHDn/1KI31aBMWnzwCgd+I9ZcVgwBARgen4cUzx8bjUcGkAIUTDER8fj8lkom/fvrZ9fn5+tGvXzvZ6//79mM1m2rZtW+7YoqIi/P39L3lus9nM66+/ztdff83p06cxmUwUFRXh5ubm/A9yCV26dLE9DwwMxM3NjVatLtxCCwgIYNeuXYC1LoqLixkwYIDtfb1eT58+fTh48CAABw8eLFdXAP369Sv3et++ffz55598+eWXtn2qqmKxWEhISCA6Otp5H7ARk6RFUHzG+UkLgCGqlS1pYeBAp55bCNGw5ebmotVq2bVrF1qtttx7Hh4elzzurbfeYs6cOcyePZvOnTvj7u7OpEmTMJlMtjIajabCbefi4mKnxa6/aCkTRVHKvS7bZ3HyxJm5ubk88sgjTJw4scJ74U4a1XklkKRFUJycDIA+xLmtIS5RUeSuXUfRsWNOPa8Qon5FRUWh1+vZvn277Qs1IyODI0eOMHjwYMDa6dVsNpOWlsagQYOqfe7NmzczfPhw/vnPfwJgsVg4cuQIHTp0sJVp3rw5yaX/bwFkZ2eTkJBwyXMaDAbA2orjbFFRURgMBjZv3kxERARgTaB27txpm08lOjqaH374odxx27ZtK/e6R48exMXF0bp0wVlROUlaRO21tLS0NqeaEk849bxCNBXHs2pv0dG/D3m2h4eHB+PGjWPq1Kn4+/sTEBDA888/j0ZzoZtk27ZtuffeexkzZgyzZs2ie/fupKens379erp06cItt9xS6bnbtGnDt99+y5YtW/D19eWdd94hNTW1XNJy7bXXsmDBAoYNG4aPjw/Tpk2r0JpzsYCAAFxdXVm9ejUtWrTAaDTi7e1t12e+FHd3dx577DGmTp2Kn58f4eHhzJw5k/z8fMaNGwfAo48+yqxZs5g6dSoPPfQQu3btYsGCBeXO88wzz3DVVVcxYcIEHnroIdzd3YmLi2Pt2rXMnTvXKbFeCSRpaeLMOTlYcnIA6wrPzqSPtP7VYariLyAhREW+Lr646lyJ/S22zq7pqnPF18W32uXfeustcnNzGTZsGJ6enkyZMoWsrKxyZebPn8+rr77KlClTOH36NM2aNeOqq67i1ltvveR5X3jhBY4fP05MTAxubm48/PDDjBgxoty5Y2NjSUhI4NZbb8Xb25tXXnmlypYWnU7He++9x7///W+mTZvGoEGDbB1pneGNN97AYrFw3333kZOTQ69evVizZg2+vtb6DA8PZ+nSpfzrX//i/fffp0+fPrz++us8+OCDtnN06dKFTZs28fzzzzNo0CBUVSUqKopRo0Y5Lc4rgaLKeNTLys7Oxtvb267plutT3Lk4Rq0YxZJbl9DBv0OVZQsPHyFh+HC03t603b6tyrL2Xqs4K4tjfa8CoO0fO9FWcR9bWFksFpKSkggPDy/3V6uoWmOut8LCQhISEmjZsiVGo9G2vzFO498UqKqKyWTCYDCgKEp9h9NgXOr3GCAzMxNfX1+ysrLw8vKq0XWkpaWJKz5zGgBdqPNno9R6eoKvL2RkYEo8gWunjk6/hhBXqmCP4FpNIuTLVzRGDe5Pkg8++IDIyEiMRiN9+/atckKhAwcOcOeddxIZGYmiKJdcaMueczY1tdWfpYwmNBQAUyWzPwohhBD2aFBJy5IlS5g8eTLTp09n9+7ddO3alZiYGNIuMTlZfn4+rVq14o033iAoKMgp52xqSspGDgXXTtKiSNIihBDCSRrU7aF33nmH8ePH88ADDwAwb948fvrpJz799NMKUx4D9O7dm969ewNU+r4j5wTr5EdFRUW219nZ2YD1vrmzx+bXBtWi2h4vF6+pdGI5XXCQQ5+tqmtZLBYobcEpSkhoFHVX38p+x6Su7NOY681isaCqqm2rD9K10TFSbxeU/f5W9u/Qmf8uG0zSYjKZ2LVrF7GxF3rLazQarr/+erZu3Vqn55wxYwYvv/xyhf2nTp2yJTANWXKOtfUkOSUZ97yqF0AsLO1xn2UwkOvA4oZVXUtVVfJ9vHEBco8cIUkWT7wsVVXJyMhAURTpZ2CHxlxvZrMZs9lMcXFxnXcivnjafVF9Um8VFRcXYzabSU5OrjD83Jnfmw0maTl79ixms5nAwMBy+wMDAzl06FCdnjM2NpbJkyfbXmdnZxMWFkaLFi0axeihvHPWVUGDg4IJ9696JsX48+cpAYI6d8bVgVkXq7qWxWLB3K4dxYBy5gxhYWGN7gulrpX91R0WFtboRsHUp8Zcb4WFhSQmJqLX622ToNWl+rjmlUDqrTyLxYJWqyU4OLjS0UPO0mCSlobExcUFFxeXCvs1Gk2j+A9R0Si2x6riVU0mStLTAXBp0cKhz3a5a2lDQihWFCx5eajnz6MtXbhMXFrZ71lj+F1rSBprvWk0GlsLUV0m9Rff2pA/JqpP6q1yZb+/lf0bdOa/yQbzr7tZs2ZotVpSU1PL7U9NTb1kJ9v6OOeVpDgtHVQVxWBAe5lVTx2lGAzopTOuEEIIJ2gwSYvBYKBnz56sX7/ets9isbB+/foKq2HW5zmvJCVp1mROFxBQq38xGCIjASiSpEUIIUQNNJikBWDy5Ml8/PHHLFy4kIMHD/LYY4+Rl5dnG/kzZsyYcp1qTSYTe/fuZe/evZhMJk6fPs3evXs5dtECfZc7Z1NWkpICgC4o8DIla0ZfmrRIS4sQV7YhQ4bYFgmsrmXLltG6dWu0Wq3dx1ZFURSWLVvmtPM528aNG1EUxa7+HpGRkZecjwxg7NixjBgxwq44XnrpJbp162bXMfWpQfVpGTVqFOnp6UybNo2UlBS6devG6tWrbR1pk5KSyt0bO3PmDN27d7e9fvvtt3n77bcZPHiwbV2Jy52zKStOtc5Vow+o3bowlK1BJAsnCiH+5pFHHuGBBx5g4sSJeHp61so1EhMTadmyJXv27GlUX9CiogaVtABMmDCBCRMmVPre3xe4ioyMrNY4+arO2ZTZWlpqOYEruz0kCycKIS6Wm5tLWloaMTExhNTSrNziytKgbg+JulVc2qdFX8u3hwwRkQCYTp5ElfkNhKiSqqpY8vPraCso99qeydLy8vIYM2YMHh4eBAcHM2vWrAplioqKeOqppwgNDcXd3Z2+ffva/vjcuHGjrWXl2muvRVEUNm7cyLlz5xg9ejShoaG4ubnRuXNnvvrqq3Lnrew2Sbdu3XjppZcqjbVly5YAdO/eHUVRGDJkSKXlym7ZrFmzhu7du+Pq6sq1115LWloaq1atIjo6Gm9vb8aMGUN+fn65zzlx4kQCAgIwGo0MHDiQnTt3ljv3ypUradu2La6urlxzzTUkVnK7/Pfff2fQoEG4uroSFhbGxIkTycvLqzTW6ti5cyfNmzfnzTfftO174403CAwMxNPTk3HjxlFYWFjhuE8++YTo6GiMRiPt27fnww8/dDgGZ2twLS2i7pSU3h6q7ZYWXXAQisGAajJRfOYMBgfmgxGiqVALCjjco2e9XLvd7l0obm7VKjt16lQ2bdrE8uXLCQgI4LnnnmP37t3lbr9MmDCBuLg4Fi9eTEhICN9//z1Dhw5l//799O/fn8OHD9OuXTuWLl1K//798fPzIz09nZ49e/LMM8/g5eXFTz/9xH333UdUVBR9+vRx6HPt2LGDPn36sG7dOjp27HjZOVZeeukl5s6di5ubGyNHjmTkyJG4uLiwaNEicnJyuOOOO3j//fdts6o//fTTLF26lIULFxIREcHMmTOJiYnh2LFj+Pn5cfLkSe644w4ef/xxHn74Yf744w+mTJlS7prx8fEMHTqUV199lU8//ZT09HTbXYL58+fb/Zl/+eUX7rjjDmbOnMnDDz8MwNdff81LL73EBx98wMCBA/n888957733aNWqle24L7/8kmnTpjF37ly6d+/Onj17GD9+PO7u7tx///12x+FskrQ0YbbbQ7Xcp0XRaDBERFB09CimxERJWoRo5HJzc/nf//7HF198wXXXXQfAwoULadGiha1MUlIS8+fPJykpyXbr56mnnmL16tXMnz+f119/nYCAAAD8/Pxs01CEhoby1FNP2c7zxBNPsGbNGr7++muHk5bmpfND+fv7V2u6i1dffZUBAwYAMG7cOGJjY4mPj6dVq1aoqsrtt9/Oxo0befbZZ8nLy+Ojjz5iwYIF3HTTTQB8/PHHrF27lv/9739MnTqVjz76iKioKFtrVLt27di/f3+5FpAZM2Zw77332jojt2nThvfee4/Bgwfz0UcfVZiwrSrff/89Y8aM4ZNPPmHUqFG2/bNnz2bcuHGMGzfO9jnXrVtXrrVl+vTpzJo1izvuuAOwtlLFxcXxn//8R5IWUX9Ui4Xi0onlavv2EFj7tZQlLVx9da1fT4jGSnF1pd3uXbV+HVVVMZmKMRj0tikPFFfXah0bHx+PyWSib9++tn1+fn60a9fO9nr//v2YzWbatm1b7tiioiL8/f0veW6z2czrr7/O119/zenTpzGZTBQVFeFWzRYgZ+jSpYvteWBgIG5ubuVaIwICAti1y/ozio+Pp7i42JbkAOj1evr06cPBgwcBOHjwYLm6AipMu7Fv3z7+/PNPvvzyS9u+srV8EhISiI6Orlbs27dvZ8WKFXz77bcVRhIdPHiQRx99tEIcGzZsAKy3/OLj4xk3bhzjx4+3lSkpKcHb27ta169tkrQ0UeaMDCguBkVBVwez1BpK7ynLsGchqqYoSrVv0dSEqqpodCY0BkOtzNOUm5uLVqtl165dFdai8fDwuORxb731FnPmzGH27Nl07twZd3d3Jk2ahMlkspXRaDQV+t8UFxc7LXa9Xm97rihKuddl+5y9OGdubi6PPPIIEydOrPBeuB2t01FRUfj7+/Ppp59yyy23VIj9cjGAtaXo70nW33+G9UU64jZRxaW3hrTN/FHs+KV2lEHmahHiihEVFYVer2f79u22fRkZGRw5csT2unv37pjNZtLS0mjdunW5rapbNJs3b2b48OH885//pGvXrrRq1arcecF6uyc5Odn2Ojs7m4QqRieW9WExm812f9bLiYqKwmAwsHnzZtu+4uJidu7cSYcOHQCIjo5mx44d5Y7btm1budc9evQgLi6uQl21bt3arnWOmjVrxi+//MKxY8cYOXJkuWQuOjq63M/s73EEBgYSEhLC8ePHK8RQ1pm5vknS0kSV1NEcLWVss+ImJNbJ9YQQtcfDw4Nx48YxdepUfvnlF/766y/Gjh1bbh6ttm3bcu+99zJmzBi+++47EhIS2LFjBzNmzOCnn3665LnbtGnD2rVr2bJlCwcPHuSRRx6psBTLtddey+eff85vv/3G/v37uf/++6tsCQgICMDV1ZXVq1eTmppKVlZWzSuhlLu7O4899hhTp05l9erVxMXFMX78ePLz8219Rx599FGOHj3K1KlTOXz4MIsWLWLBggXlzvPMM8+wZcsWJkyYwN69ezl69CjLly93aLqOgIAAfvnlFw4dOsTo0aNtq1I/+eSTfPrpp8yfP58jR44wffp0Dhw4UO7Yl19+mRkzZvDee+9x5MgR9u/fz/z583nnnXccqyAnk6SlibJN4V9Hk+yVTTBXkpyMpZIhdkKIxuWtt95i0KBBDBs2jOuvv56BAwfSs2f5UU/z589nzJgxTJkyhXbt2jFixAh27txZ5e2OF154gR49ehATE8OQIUMICgqq0DcjNjaWwYMHc+utt3LLLbcwYsQIoqKiLnlOnU7He++9x3/+8x9CQkIYPnx4jT77373xxhvceeed3HffffTo0YNjx46xZs0afH19AevtnaVLl7Js2TK6du3KvHnzeP3118udo0uXLmzatIkjR44waNAgunfvzrRp0xyevyYoKIhffvmF/fv3c++992I2mxk1ahQvvvgiTz/9ND179uTEiRM89thj5Y576KGH+OSTT5g/fz6dO3dm8ODBLFiwoMG0tCiqPQPzm6js7Gy8vb3JyMjAx8envsO5rLhzcYxaMYolty6hg3+HSsukzZ7NuXn/wfee0QRNm1Yr17JYLCQlJREeHo6iKBzpexWW7GxaLl+OsV3bS5yxabu4zhrbasX1qTHXW2FhIQkJCbRs2dKuESI1Ze2Ia8JQS31arlRSb5Wr6vc4MzMTX19fsrKy8PLyqtF1Gte/buE0tjla6uj2kKIoGCJKp/M/kVgn1xRCCHFlkaSliSpJrZsp/C92oTOurEEkhBDCfpK0NFG2xRLrYI6WMtLSIoQQoiYkaWmiSlLrtiMuXJy0SEuLEEII+0nS0gSZc/OwlE4iVFd9WkBuDwlRFRkTIRqzuvr9laSlCSob7qzx8EDr4V5n1y0b9mw+exZzadIkRFNXNr/IxTO+CtHYlK16bc8MvI6QafyboPq4NQSg9fRE6++P+dw5TCdO4NqxY51eX4iGSKfT4ebmRnp6Onq9vs6GbKuqSnFxMRaLRYbu2kHqrTxVVcnPzyctLQ0fH59an+5fkpYmqDjFmrToAwPq/NqGiAgKzp3DlJgoSYsQWKcDCA4OJiEhgRN12N9LVVXMZjNarVa+fO0g9VY5Hx+faq2gXVOStDRBtpaWOuzPUsYQEUHB7t3SGVeIixgMBtq0aVOnt4gsFgvJyckEBwc3ugn56pPUW0V6vb7OFlSUpKUJKklPB0AXUA8tLbJwohCV0mg0dTojrsViQavVYjQa5cvXDlJv9UtqvAmyJS3Nm9f5tWXYsxBCCEdJ0tIE1WvS0jISgGIZ9iyEEMJOkrQ0QSVnzwKga96szq9tKF3d1ZyVRUlGRp1fXwghROMlfVqaGFVVHW5pOZ1ZQEZe+Y6CCdnW+Vbi03KxFGaVe89isZCSXkC2NqvcvV9Ns+YoZ9M59Eccvr17EOrj6shHEUII0cTUKGkpLi4mJSWF/Px8mjdvjp+fn7PiErXEkpuLWlgI2Je0nM4s4PpZmygoNpfbrzGexr0lPLlkL5bC9Escfbzcqxl40Y103p2/ji2/5rBuymBJXIQQQlyW3UlLTk4OX3zxBYsXL2bHjh2YTCZUVUVRFFq0aMGNN97Iww8/TO/evWsjXlFDZa0sGg8PNK7VTxQy8kwUFJuZPaobrQM8bPsTsg/z3A6YM6obLb3alTvGYrGQkpJCUFBQuZYWpfh3+CmesRFa1hebycgzSdIihBDisuxKWt555x1ee+01oqKiGDZsGM899xwhISG4urpy/vx5/vrrL3777TduvPFG+vbty/vvv0+bNm1qK3bhgJL00v4szRzrz9I6wINOod621xqjNYGJCvCgg793ubIWiwUvcxbhod7lkpZzHduS9hP4ZaSCj0NhCCGEaILsSlp27tzJr7/+SsdLzGTap08fHnzwQebNm8f8+fP57bffJGlpYOpz5FCZsjWIlFNJkrQIIYSoNruSlq+++qpa5VxcXHj00UcdCkjUroaRtERan5w+BR1lZVshhBDVU6tDnrdv316bpxcOKDnbAJKWFi1Ao0EpyMe3KKfe4hBCCNG41GrScvfdd9fm6YUDLrS01P0cLWUUgwF9SAgAobmXGnEkhBBClFfjeVpGjhxZ6X5VVTl//nxNTy+crCHcHgLrLaLiU6cIyT1br3EIIYRoPGqctKxbt47PP/8cDw+PcvtVVeXXX3+t6emFk9VW0nI863iFfapFJTknmbxzeSiavy3hHuiJAoQVJpCQfdg2CulyfF18CfYIdkLEQgghGpsaJy1DhgzB09OTq6++usJ7Xbp0qenphZOZy4Y8Oylp8XXxxVXnSuxvsXYdNzTbwoNAmGUXz+0YV+3jXHWuLB++XBIXIYRogmqctHz33XeXfG/t2rU1Pb1wIovJhDnLOtW+1sF5Wv4u2COY5cOXk1FUcR0h1aKSnJJMcFBwxZaWZntg7asEpvrxep93iAq4fEvL8azjxP4WS0ZRhiQtQgjRBMnaQ02IufTWkKLXo/Xxcdp5gz2CK00iLBYL7nnuhPuHl5tcDsDU2YN4IDgnC51HGzr4+zotHiGEEFcmh0cPPfjggyxYsMD2+sSJE6xatYqsrKxLHyTqVVl/Fm3zZiiKcpnStUsfEoKq0+FiKYH0tHqNRQghROPgcNKycuVK2rdvD0BmZiY9e/ZkxIgRdOjQgcOHDzsc0AcffEBkZCRGo5G+ffuyY8eOKst/8803tG/fHqPRSOfOnVm5cmW593Nzc5kwYQItWrTA1dWVDh06MG/ePIfja8xKzpZN4V+/I4cAFJ0OgkOtL04l1W8wQgghGgWHk5asrCxCQ61fOkuXLiUoKIjs7GxGjRpFbKx9nTLLLFmyhMmTJzN9+nR2795N165diYmJIS2t8r/Et2zZwujRoxk3bhx79uxhxIgRjBgxgr/++stWZvLkyaxevZovvviCgwcPMmnSJCZMmMAPP/zgUIyNWUMZ7mzTIgwA5fTJeg5ECCFEY+Bw0hIWFkZCQgJgbe0YO3asbfr+zZs3O3TOd955h/Hjx/PAAw/YWkTc3Nz49NNPKy0/Z84chg4dytSpU4mOjuaVV16hR48ezJ0711Zmy5Yt3H///QwZMoTIyEgefvhhunbtetkWnCtRQ5hY7mJqqDVp4ZQkLUIIIS7P4Y64Y8eOZeLEiQwbNoz169fbEgWLxUJubq7d5zOZTOzatatcK41Go+H6669n69atlR6zdetWJk+eXG5fTEwMy5Yts73u378/P/zwAw8++CAhISFs3LiRI0eO8O67714ylqKiIoqKimyvs7OzbZ/NYrHY/dnqmmpRbY8Xx1tc1qelWTO7P0dZeXvqoKzspcqrIS2sT04lVeucl/pcV5LL1ZmonNSb/aTOHCP1Zj9n1pXDSUtsbCyqqvLzzz/zxhtv0Lp1a8C6EnR4eLjd5zt79ixms5nAwMBy+wMDAzl06FClx6SkpFRaPiUlxfb6/fff5+GHH6ZFixbodDo0Gg0ff/xxpfPKlJkxYwYvv/xyhf2nTp2yJTANWXJOsvUxJRn3PHfb/qIka9+RbI2G/CT7+pGkpBdYH1NS8DJXr7O1qqpkZGSgKEqlHX/PuXkQAJhPJJJUjXgu9bmuJJerM1E5qTf7SZ05RurNfs783nQ4aVEUheeff57nn3++3P6UlBTuueeeGgfmLO+//z7btm3jhx9+ICIigl9//ZXHH3+ckJAQrr/++kqPiY2NLdeCk52dTVhYGC1atMDHiUOFa0veuTwAgoOCCfe/kEAm5uZRBAS0a4eHnYlltjYLOE5QUBDhod7VOsZisaCqKmFhYRWGPANkdy4EQJeeSlhIiLVzbhUu9bmuJJerM1E5qTf7SZ05RurNfpmZmU47l8NJy4MPPsjVV1/N2LFjAeuQ57i4OB5++GG8vav3pXaxZs2aodVqSU1NLbc/NTWVoKCgSo8JCgqqsnxBQQHPPfcc33//PbfccgtgnaV37969vP3225dMWlxcXHBxcamwX6PRNIpf0rKJ3BSNUi7esnla9AGBdn+OsvL21kFZ+cqO0QQEUqjVYzQXY05OxhARUeW5LvW5rjRV1Zm4NKk3+0mdOUbqzT7OrKdaGfJ85MgRu89nMBjo2bMn69evt+2zWCysX7+efv36VXpMv379ypUH6yy8ZeWLi4spLi6uUGFarbbJ3Y9ULRZKzp0DQBfQQEYPaTQku1s7BZsSE+s3FiGEEA1erQx5fvbZZx065+TJk/n4449ZuHAhBw8e5LHHHiMvL48HHngAgDFjxpTrqPvkk0+yevVqZs2axaFDh3jppZf4448/mDBhAgBeXl4MHjyYqVOnsnHjRhISEliwYAGfffYZt99+u6MfvVEyZ2SA2QyKgs7Pr77DsTntUZq0nDhRz5EIIYRo6By+PVQ25DksLKzCkOdBgwY5dM5Ro0aRnp7OtGnTSElJoVu3bqxevdrW2TYpKalcq0n//v1ZtGgRL7zwAs899xxt2rRh2bJldOrUyVZm8eLFxMbGcu+993L+/HkiIiJ47bXXePTRRx396I2SbTZcX18Uvb6eo7ngtLu11ceUKEmLEEKIqjWYIc9lJkyYYGsp+buNGzdW2Hf33Xdz9913X/J8QUFBzJ8/3+F4rhQNbmK5Umc85PaQEEKI6mkwQ55F7SpJL5vCv2FMLFfmtEdpS4vcHhJCCHEZV/yQZ2HVUFtaTpd2xC0+cwZLURGaSkZtCSGEEFCDpMVsNvPJJ59w+PBhWrRoQdeuXenWrRtTp051ZnzCSRpq0pLp4oHq7o6Sl0fxyZO4lLbYCSGEEH/ncNLyxBNPsHTpUq6//nrmzp2LoiiUlJQQGhpK9+7dWb58uTPjFDVkW+G5gSUtKAqEhsGRQ5hOnJCkRQghxCU5POT5u+++47PPPuPLL7/ExcWFP/74gzlz5lBYWCh9WhqghrZY4sXKFk6UzrhCCCGq4nBLS25uLh06dABAr9ej0+mYMGECxcXFnDlzxmkBCudoqLeHAGhhTXJl2LMQQoiqONzS0qpVK1tyEhoayunTpwEYNmwYX3zxhXOiE06hqmrDTlpCras9S0uLEEKIqjictNxxxx2sWrUKgMGDB/Ppp58CEBcXR0FBgXOiE05hyctHLf2ZNLQhzwBqWGlLiwx7FkIIUQWHbw+99NJLtudPP/00vXv3pnnz5mRnZzNu3DhnxCacpCQ9DQCNmxsad/d6jqYSpX1aStLSsOTlNcwYhRBC1DuHk5aLhYeHc+DAAX788Uf8/f0ZNmyYM04rnKRB3xoC8PRC6+ODOTMTU1ISxujo+o5ICCFEA+SUpAWgWbNmtoUNRcPS4JMWwNCyJQV79lB0/LgkLUIIISrlcNKSnZ3N/PnzSUlJoWXLlnTt2pXOnTvj5ubmzPiEE5jL5mgJaMBJS1QrCvbswRR/vL5DEUII0UA5nLTccccd7Nu3j969e/Pjjz9y+PBhAKKioujatStLlixxWpCiZmwrPDfATrhlXFpFAVB0XJIWIYQQlXM4adm6dSsbN26kd+/eABQVFbF//3727t3Lvn37nBagqLnGcHvIJaoVAKb4+HqORAghREPlcNLSpUsXdLoLh7u4uNCrVy969erllMCE8zSGpMUQZW1pMSUmopaUoOic1t1KCCHEFcLheVpmzpzJtGnTKCoqcmY8ohaUpJf2aWnWcJMWfUgIitGIWlxM8alT9R2OEEKIBsjhpCUyMpLs7Gw6dOjAc889xw8//MDJkyedGZtwksbQ0qJoNBhatgSkX4sQQojKOZy03HnnnSQmJjJgwAC2bNnC/fffT2RkJM2bN+fGG290ZoyiBlSTCXNmJtCwRw8BuLSy9mspkn4tQgghKuFwx4G//vqLrVu30rVrV9u+xMRE9uzZw59//umU4ETNlZw7Z32i16P19q69C+WdhZxk8AgE9+agKHafwmDrjCstLUIIISpyOGnp3bs3eXl55fZFRkYSGRnJ7bffXuPAhHPYbg35+6NoHG5Yq5yqwr7FsHUupP51YX/z9tBnPHS/367TybBnIYQQVXH4W+zJJ5/kpZdeIrP01oNomGqtP0tBJiwaBcsevZCwuPmDooH0Q/DTFJRPb0Cbe6bap7x42LOqqs6NVwghRKPncEvLXXfdBUCbNm24/fbb6du3L927d6dTp04YDAanBShqplaSloIM+GwEJO8FrQsMngq9xoGbHxRmwd5FsHEGypk9hKz4J/h9DyFdL3dWDBERoNViycujJC0NfWCg82IWQgjR6Dnc0pKQkMCyZcuYMGEC586d4/XXX6d37954enrSpUsXZ8YoasA23NlZSYulBJbcZ01Y3PzhobVw9VRrwgJg9IarHoPHtqAGdkRbeA7lyzvh7LHLnloxGDCEWVd8lknmhBBC/J3DLS0RERFERERw22232fbl5OSwd+9e6YjbgNhaWpw0hX/gH29B4m+gd4cxP0BQp8oLerdAvf8nTJ/E4HL+MHw1CsZvAKNXlec3REVhSkykKP447v37OyVmIYQQVwaHk5asrCymTp3KL7/8gl6v55dffiE4OJhBgwYxaNAgZ8YoHBSflkvUyTMoQJreg9TTWQ6f61haLt2VozTbN8+6Y8QHl05Yyhi9Sb3hI8JW3Ydy7hgsfxxGflblyCKXVq3IXb+eouPS0iKEEKI8h5OWxx9/nPj4eGbOnMk///lPCgoKAPjXv/5FVFQUEyZMcFqQwj5pOdZZip9cspd3DybSFvj31jS2J/7u8Dl1lLDK5WMUVOg6GjpWb4SYxdUf9e6FKPNvgoM/wP5vocvdlywvw56FEEJcisNJy6pVq1i3bh3du3dHq9Xa9sfExPDiiy9K0lKPcgqKAXjqhra0WW8C4MUxA6F9R4fP6Rf3OSGbT1n7scS8bt/BoT1h8DOw4VVYNRVaDQaPgEqLukTJsGchhBCVczhpUVUVT0/PCvvbtGnD0aNHaxSUcI4wHyNKxnkA2nVoiT7YwcnlinJg72zr8yGxFzrd2mPgJGtLS8qfsOppuHtBpcUMLa0tLeazZzFnZdXuhHhCCCEaFYdHD9100018+eWXFfbn5eWhODAbqnA+TU4ulJQA1snlHLbzf5CXDn6toOdYx86h1cPwD6zzuBz4HhI3V17Mwx1dUBAARXKLSAghxEUcbmmZMWMGvXr1AqytLoqiUFhYyCuvvEKPHj2cFqBwnC4jEwCtjw+Ko3PnlBTBto+sz6+eak0+HBXcxZr0/PEprImFW5ZXWsylVStKUlIwHY/HrUd3x68nhBDiiuJwS0t4eDhbtmxhy5Yt5Ofn06dPH3x8fNi0aRNvvvmmM2MUDtJlWEcL6QIq7z9SLX9+Dbkp4BkCne6qeVDXPA8uXpC8D5+jSystYmhd2q/lmIwgEkIIcYHDLS0ArVu3Zs2aNSQlJbFv3z70ej19+/bF19fXWfGJGtCWtrQ4PLGcxQJb3rM+7/d/oHPCTMfuzeDqp2DtNAJ2vYOeGRWKuLRpA0DRkSM1v54QQogrhsNJy5YtW/Dy8qJTp06Eh4cTHh7uzLiEE+hqmrTE/wJnj4CLN/Swb/HDKvV5GLZ+iCH3NCO1G4Eh5d42liUt0qFbCCHERRy+PfT444+zffv2Cvvj4+PJycmpUVDCObRlt4ccTVp2L7Q+dht92Zls7aJ3hUGTAXhctwzFXFTubUNra9JSkp5OSUaG864rhBCiUXM4aTl8+DBDhgypsH/dunWMHj26JjEJJ9Gdz7Q+OtKnJTcdDq+0Pu9+n/OCKtPjfordgwhRzuN7aHG5t7Qe7uhbtACg6Ii0tgghhLByOGnx8vIio5K/ggcNGsS2bdtqFJRwjhr1adn3lXVxxNCel5+u3xF6I+ld/w+AZn/+F8wl5d6Wfi1CCCH+zuGkZejQobz99tsVT6jRYDKZHA7ogw8+IDIyEqPRSN++fdmxY0eV5b/55hvat2+P0Wikc+fOrFy5skKZgwcPctttt+Ht7Y27uzu9e/cmKSnJ4RgbC1uflgA7kxZVhd2fWZ/3GOPcoC6S0W4U51RPDLkn4WD54c8ubdsC0q9FCCHEBQ4nLa+88gqbNm3izjvvZP/+/QAUFhby5ptv0qVLF4fOuWTJEiZPnsz06dPZvXs3Xbt2JSYmhrS0tErLb9myhdGjRzNu3Dj27NnDiBEjGDFiBH/99ZetTHx8PAMHDqR9+/Zs3LiRP//8kxdffBGj0ehQjI2Gqjre0nJ6N5w7Cno36HSn82Mrpepc+azkRuuLzXOsyVIpl7bS0iKEEKI8h5OWsLAwtm/fTkFBAV27dsXV1RVPT09+/PFH3nrrLYfO+c477zB+/HgeeOABOnTowLx583Bzc+PTTz+ttPycOXMYOnQoU6dOJTo62jax3dy5c21lnn/+eW6++WZmzpxJ9+7diYqK4rbbbiOgJnOXNAJuRaAxWdcgsjtp+at0/pR2N4NLxaUanOkz8w1YtEZI3gcJv9r2Gy9qaVEvSmaEEEI0XQ4NeTabzfz4449cd911rFy5kqSkJPbu3Wubp8XPz/61aUwmE7t27SI2Nta2T6PRcP3117N169ZKj9m6dSuTJ08uty8mJoZly5YBYLFY+Omnn3j66aeJiYlhz549tGzZktjYWEaMGHHJWIqKiigqujCiJTs723Y+i8Vi92eraxbVgm+u9bnGywsMhurHrVpQDnyHAlg63m6dq8XROErr61LXtlgsZODF+bYjaXbwM9TNc1AjBwGgCw8HnQ5LXh6mU6fQh4aiWtTSENVG8XNwxOXqTFRO6s1+UmeOkXqznzPryqGkRavVMnr0aA4cOICnp6dT5mk5e/YsZrOZwMDAcvsDAwM5dOhQpcekpKRUWj4lJQWAtLQ0cnNzeeONN3j11Vd58803Wb16NXfccQcbNmxg8ODBlZ53xowZvPzyyxX2nzp1ypbANGTnzp7DJ7f0C97H267+Oy4puwjOScai9yTJ0BZq0PdHVVUyMjJQFKXS9ahS0gsAOBg0nIGHvkCJX8+ZPzdQ7GOdEVdp0QI1MZFTW7ag7duX5JxkAJJTknHPc3c4robscnUmKif1Zj+pM8dIvdnPmd+bDk8u17t3bxISEmjVqpXTgnG2suxu+PDh/Otf/wKgW7dubNmyhXnz5l0yaYmNjS3XgpOdnU1YWBgtWrTAx8en1uOuKf/8FPxKW1pcg0MIsyOhVP6aY33sMIzwlq1rFIfFYkFVVcLCwtBoKt6JzNZmAcfxbtUTkm+GQysIOfUTahdrB+8zHTuSk5iIV0Ym/uHh5J3LAyA4KJhw/ytzMsPL1ZmonNSb/aTOHCP1Zr/MzEynncvhpOWJJ57gueee49tvvyUsLKzGgTRr1gytVktqamq5/ampqQSVrvr7d0FBQVWWb9asGTqdjg4dOpQrEx0dze+//37JWFxcXHBxcamwX6PRNIpfUo2iwac0adEFBFQ/ZosZ4n4AQOl8J4oTPmtZnVUWQ9k+jUaD0udhOLQCZd9ilOung9EbY7t25Pz0E6ajR61lNNa/ahSN0ih+Do6qqs7EpUm92U/qzDFSb/ZxZj05fKZRo0axc+dOOnbsyD//+U8++eQTdu3a5fBwZ4PBQM+ePVm/fr1tn8ViYf369fTr16/SY/r161euPMDatWtt5Q0GA7179+bw4cPlyhw5coSIiAiH4mwsfEtvD9nVCffUTsg/C0ZvaFl5K1StaXk1NG8PxXmw9ysAXNpYW3pkBJEQQgioQUtLQkIC+/btY+/evezbt48ZM2aQmJiITqejXbt2/Pnnn3afc/Lkydx///306tWLPn36MHv2bPLy8njggQcAGDNmDKGhocyYYV1k78knn2Tw4MHMmjWLW265hcWLF/PHH3/w3//+13bOqVOnMmrUKK6++mquueYaVq9ezY8//sjGjRsd/eiNgq+tpcWOpOXQT9bHNjeCVu/8oKqiKNBnPPw0BXZ+DH0extiuHQBFCQlYajD3jxBCiCuDw0lLREQEERER3HbbbbZ9OTk57N2716GEBaytN+np6UybNo2UlBS6devG6tWrbZ1tk5KSyjUz9e/fn0WLFvHCCy/w3HPP0aZNG5YtW0anThdmcL399tuZN28eM2bMYOLEibRr146lS5cycOBABz954+CT50BLy+FV1sd2N9VCRNXQ5R+w7mU4dwyOb0AXdS0ab28sWVnWSeaCpNObEEI0ZQ4nLefPn68wtNnT05NBgwYxaNAghwOaMGECEyZMqPS9ylpH7r77bu6+++4qz/nggw/y4IMPOhxTY2Rraalu0nL2qHVCOY0OWl9fe4FVxcUDut0D2+fBjo9RWl+HsX178rdvp+jgQQjqcPlzCCGEuGI53KelWbNmhIWFceutt/L888/z9ddfc/jwYZkIrIGwO2kpa2WJHGjt01Jfej9kfTyyGjISMUZHA1B4sPJh70IIIZoOh1ta9u/fb+vPsnPnTv773/9y/vx5jEYjnTp1Yvv27c6MU9hBKSjEtbQLiK55NWf+td0aurl2gqquZm2g1RA4vhF2f4axQzcACg8erM+ohBBCNAAOJy0dO3akY8eO3HvvvYB1wp3Vq1fzxBNPcN111zktQGG/soUSLUYjWo9qTMKWdw5Olq7M3XZo7QVWXT0fsCYte77AOMx666/o0KEazc4rhBCi8XPa4GlFUbjpppv44osvbDPSivpRtlBiiW81b/Mc/RlUCwR2At8GMBS83c3g3hxyUzEUH0ZxccGSnw+n5PdKCCGaMqfPjHPVVVexYcMGZ59W2EGXkQWA2denegccW2d9bBtTOwHZS2eAbtYWPGXv57iUDn3mSEI9BiWEEKK+OXx7yMPDg86dO9O1a1e6dOlC165dad++PTt37iQnJ8eZMQo7ac9nAFDi53P5whYLHC9NMqMa0G29nvfD5tlwbD3GVuMo/PNPOHocaj75shBCiEbK4aTl22+/Ze/evezdu5c5c+YQHx+PxWJBo9HwyiuvODNGYSe7WlpS9kH+OTB4QFif2g3MHn6tbB1yja5nrfuOJEjSIoQQTZjDScvQoUMZOvRCp838/HwSEhLw9/e/5FpBom5c6NPic/nC8b9YH1teXfez4F5Oz7HWpCVvG6CxJi3XypB6IYRoqhzu01JSUsJrr71Gv3796NGjB4899hhnzpyRhKUB0NnTEfdYadISdW3tBeSodreAWzNcDCmgUVAys23zzwghhGh6HE5ann32WT788EOuu+46RowYQVFREbfeeisPPPCATDBXz8paWsyX69NSlAMnS+fTaYhJi84A3e9FowODnwGAlinyuyWEEE2Vw7eHFi1axOLFi7n66qtt+xISErj11lt5++23mTp1qlMCFPYr69Ny2dtDib+DpRh8I8E/qtbjckiP+2HzHIzuGZjOutFKRj0LIUST5XBLS15eHi1atCi3r2XLlrz//vvlVlkWdctSWIg2Nw+oRktLfAO+NVTGPwpaDsbVvxiAqGRpaRFCiKbK4aRl4MCBLFy4sML+li1bcubMmRoFJRxXctY60sakA4ubW9WFbUlLAxrqXJmeY3H1t65L0DpZBbn9KIQQTZLDt4fefPNNBgwYQEZGBk888QRt2rShuLiY999/nw4dZDXe+lKSlg5AhgegKJcumH0Gzh0DRQMtHV+Vu060vxWXYG9UjYp3voKakg7N6jsoIYQQdc3hlpZOnTqxceNGtm7dSrt27TAajbi5ufH5558ze/ZsJ4Yo7FGSXpq0XG7JocTN1segLvW7qnN16Axoet0DviXW13FH6zceIYQQ9cLhlhaA7t27s3PnTg4fPsyBAwfw9PSkb9++eHl5OSs+YaeypCXTQ6m6MeLE79bHyIG1HpNT9BwL/p/DOT3s2wcj6zsgIYQQdc3hlpYHH3yQBQsWANCuXTt69uxJSUmJDHeuZ2pJMWZ3N+vtoaqUtbREDKj1mJzCPwrahFqf791Tv7EIIYSoFw4nLStXrqR9+/YAZGZm0rNnT0aMGEGHDh04fPiw0wIU9vEfO5aELz5iwQ1V/GhzUuDcUUCBiH51FluNDSxd0PHEOdSiwvqNRQghRJ1z+PZQVlYWoaHWv3yXLl1KUFAQp0+fJjY2ltjYWL777junBSnsp1bVCfdEWX+WTuDqWzcBVeFYWvWmuU2MuoZgw1e4mRQSl31C3sD7KpTxdTcQ6uPq7BCFEEI0AA4nLWFhYSQkJBAWFsY333zD2LFjcXFx4dFHH2XQoAY+GqWps90aqt/+LL7uBlz1WiYt2Vut8hrjad4MVuh0QiX1x4X8Y0/LCmVc9VrWTRksiYsQQlyBHE5axo4dy8SJExk2bBjr169n7ty5AFgsFnJzZYGYBq2spSWyfvuzhPq4sm7KYDLyTNUqn5B9mL8SodMJiMhIZc0LkRR7Xpjg8FhaLpOW7CUjzyRJixBCXIEcTlpiY2NRVZWff/6ZN954g9atWwOwc+dOwsPDnRagcLK8s5B+yPo8vH/9xoI1calugqExerA8WAFUCs4ZaHfme7j2hdoNUAghRIPhcEdcRVF4/vnn2bRpE1OmTLHtT0lJ4Z577nFKcKIWlLWyBHQAd//6jcUBR0KtfXWKsnSYt30O5pJ6jkgIIURdqdE8LZWRhRIbuMY21PlvMjwV1KDmKCnpFCSdx+PIaoi+tb7DEkIIUQfsamlJSkqy6+SnT5+2q7yoAw2kP0uNdI0GoCDdALsW1G8sQggh6oxdSUvv3r155JFH2Llz5yXLZGVl8fHHH9OpUyeWLl1a4wCFE+Wfh9QD1ueNtKUFgM7W+YHyzxrg2DrIOFHPAQkhhKgLdt0eiouL47XXXuOGG27AaDTSs2dPQkJCMBqNZGRkEBcXx4EDB+jRowczZ87k5ptvrq24hSNObAFUaNYWPALqOxrHlbW0nDeiWlSUPZ9Lh1whhGgC7Gpp8ff355133iE5OZm5c+fSpk0bzp49y9Gj1gXs7r33Xnbt2sXWrVslYWmIbLeGGsl6Q5cS2QKNlxdqsUphph52fw7m4vqOSgghRC1zqCOuq6srd911F3fddZet30rZ7LiiAUssXSSxMd8aAtBocO3ejbxNv1KQ5YdrbgocWQNeMqmhEEJcyRwe8rx582ZatmxJeHg44eHhBAYG8swzz5Cdne3M+ISzFGRCyn7r88be0gK49egJQL4pwrpj1/x6jEYIIURdcDhpeeSRR4iOjmbnzp0cPnyYt956i3Xr1tGjRw8ZNdQQJW0DVPCLAs+g+o6mxtx6dAeg4GQ+qgocW48+WzrkCiHElczhpCU+Pp7Zs2fTo0cPWrduzZgxY/jjjz/o3r07kyZNcmKIwilOlN4aasxDnS9i7NwZ9HpKzp6n2H8QoOIf93l9hyWEEKIWOZy0REdHk5aWVm6foij8+9//ZvXq1TUOTDhZA1kk0Vk0RiOuHTsCkK/rA4Dv4cW4UlifYQkhhKhFDictY8eO5YknnuDkyZPl9mdlZeHl5VXjwIQTFeVA8j7r8yukpQXArW9fAPIT88C3JVpTNiO0m+s5KiGEELXF4Wn8y24BtWnThjvuuINu3bphNpv54osvmDlzprPiE86QtB1UM/hEgHeLy5dvJNyv6su5//yHvO3bUWc8hPLz89yv/ZkSdVp9hyaEEKIWOJy0JCcns3fvXvbt28fevXtZsGABR48eRVEUZs6cyapVq+jSpQtdunRh6NChzoxZ2MvWn+XKuDVUxrV7dxSDgZLUVEy+g9DrXGlfcpKE5G3QQn7nhBDiSuNw0hIYGEhMTAwxMTG2fYWFhezfv9+WzPzwww+8/vrrZGZmOiNW4agrZX6Wv9EYjbh2707+9u3k741DbX0Hfoe+xC9uAfSWpEUIIa40DvdpqYzRaKR3796MHz+euXPn8vvvvzuUsHzwwQdERkZiNBrp27cvO3bsqLL8N998Q/v27TEajXTu3JmVK1desuyjjz6KoijMnj3b7rgaJVMenNljfX4F9Wcp436VtV9L3rbtnOs4FgCvxJ8h61Q9RiWEEKI2ODVpcYYlS5YwefJkpk+fzu7du+natSsxMTEVRiqV2bJlC6NHj2bcuHHs2bOHESNGMGLECP76668KZb///nu2bdtGSEhIbX+MhuPkdrCUgHeYtU/LFcat71UA5G/fTpFPG7aYO6CoZtj5v3qOTAghhLM5fHuotrzzzjuMHz+eBx54AIB58+bx008/8emnn/Lss89WKD9nzhyGDh3K1KlTAXjllVdYu3Ytc+fOZd68ebZyp0+f5oknnmDNmjXccsstVcZQVFREUVGR7XXZLL8WiwWLxVLjz1jbLKrF9qgm/I4CqBH9UVUV60xsdRRHaX05q85Ui2p7LDunS8cOKK6umDMzscQfZaE5hv7aONRd81EHTgaDu1OuXVecXWdNhdSb/aTOHCP1Zj9n1lWDSlpMJhO7du0iNjbWtk+j0XD99dezdevWSo/ZunUrkydPLrcvJiaGZcuW2V5bLBbuu+8+pk6dSsfSuT2qMmPGDF5++eUK+0+dOtUolik4d/ac7bHoyC8YgXMe7clNSqrTOFRVJSMjA0VRUBSlxudLzkm2PqYk4553IRlROnVE3fkHub9uZK2lJ/luLXDLP8X5DXPJiR5d4+vWJWfXWVMh9WY/qTPHSL3Zz5nfmw0qaTl79ixms5nAwMBy+wMDAzl06FClx6SkpFRaPiUlxfb6zTffRKfTMXHixGrFERsbWy4Rys7OJiwsjBYtWuDj41PNT1N//PNTIAGa+Xjicu4AAH49bsPPL7xO47BYLKiqSlhYGBpNze9E5p3LAyA4KJhw/wuf5fzgIaTv/APvY4ewhHQko+sjuG19Eb/DX+F7w1Og0db42nXF2XXWVEi92U/qzDFSb/Zz5mCcBpW01IZdu3YxZ84cdu/eXe2s2MXFBRcXlwr7NRpNo/gl1SjWGN0yD6OYTeAZjMY/Curhr4KyOnNGvSkaxfZ48fk8Bg0k/e23UfbtRh94G5ntRxK6912UzBMoh1dAx9trfO265Mw6a0qk3uwndeYYqTf7OLOeGlSNN2vWDK1WS2pqarn9qampBAVVvshfUFBQleV/++030tLSCA8PR6fTodPpOHHiBFOmTCEyMrJWPkdDYTxbuqpzxIB6SVjqikvbtugCA1GKiuh89jiqzhX6jLe+ufm9Ou3HI4QQovY0qKTFYDDQs2dP1q9fb9tnsVhYv349/fr1q/SYfv36lSsPsHbtWlv5++67jz///JO9e/fatpCQEKZOncqaNWtq78M0AK5nS0dQXYFDnS+mKAoeVw8CoHfqQevO3uNBZ4Qzu+HElnqMTgghhLM0uNtDkydP5v7776dXr1706dOH2bNnk5eXZxtNNGbMGEJDQ5kxYwYATz75JIMHD2bWrFnccsstLF68mD/++IP//ve/APj7++Pv71/uGnq9nqCgINq1a1e3H66OGc+X9gO6QhZJrIr71VeT+c239E4t/cwezaHraNg1H7a8f8UnbkII0RQ0qJYWgFGjRvH2228zbdo0unXrxt69e1m9erWts21SUhLJycm28v3792fRokX897//pWvXrnz77bcsW7aMTp061ddHaDAUiwncA6BZm/oOpda59+uHqtUSmncWTpWOkuo3AVDgyCpIP1yv8QkhhKi5BtfSAjBhwgQmTJhQ6XsbN26ssO/uu+/m7rvvrvb5ExMTHYysEYrof0X3Zymj9fCAzt1g7y6UHVuhb2do1hra3wKHVsDmOTDiw/oOUwghRA00uJYW4WRX2CKJVVH79gewJi1lBpYOXd+3GDIS6z4oIYQQTiNJyxVIsRRfeNGUkpY+pZ219+7Gkp9vfd6iJ0RdB6oZfnun/oITQghRY5K0XIEMmUcBMBu8oXn7eo6mDkW0JNXVF6XYRN7FMygPfsb6uHcRZJ6sn9iEEELUmCQtVyDX0vlZCpp1ahL9WWwUhS0h1g7YOT+vvbA/vC+0vBosxbB5dv3EJoQQosYkabkCuaZb52cpaNb0RlBtDu4MQM6GDajFF90mK2tt2f0ZZJ+ph8iEEELUlCQtVxpzMcbzcQAUNutcz8HUvYP+kag+vliys8nbsePCG5EDrTMDm03w+7v1F6AQQgiHSdJypSkuIKvVrQCYvCLrN5Z6YFE0qAMGA5Czdm35N8taW/6YDxkn6jgyIYQQNSVJy5XG6MX5jtbZg1Ga5o9XHTQEgJx161HN5gtvtBoMrYZY+7ZsnFEvsQkhhHBc0/xWE1e2bj3ReHpiPnuWgn37yr933TTr477FkBpX97EJIYRwmCQt4sqj1+NxzRAAcv6+KGZoT+gwHFDhl1fqOjIhhBA1IEmLuCJ5DR0KQPbKVeVvEQFc+yIoWji8EpK210N0QgghHCFJi7gieQwciNbbm5L0dPIvHkUE1gUku91jfb5uOqhq3QcohBDCbpK0iCuSYjDgWdrakvXDjxULDIkFnSskbYUD39dxdEIIIRwhSYu4YnkPsw79zvn5ZyyFhX97MxQG/sv6fO00MOXXcXRCCCHsJUmLuGK59uiBLiQYS14euRs3VizQ/wnwagFZJ2HL+3UenxBCCPtI0iKuWIpGg/ct1taWSm8RGdzgxn9bn//+LmSdqsPohBBC2EuSFnFF8yq9RZT722+UnD9fsUDHOyC8H5QUwNrpdRydEEIIe0jSIq5oxrZtMXbsCMXFZC1bXrGAosDQNwAF/voW4n+p8xiFEEJUj66+AxDCXsezjle6PyE7F43xNAnZh9EYPS68cfNAlAMHSF38Bam39bEmKhdzMUD3UXBgKayaBHctAL0RXxdfgj2Ca+1zCCGEsI8kLaLR8HXxxVXnSuxvsZcs494SnvvbtCyuZpX/6MGYdIbpH43iYLhS+cGhwYAKa+63HqdzZfnw5ZK4CCFEAyFJi2g0gj2CWT58ORlFGZW+H5+Wy5NL9vLUDW0J83Mr917Rn59iXLeJKaf6knbXI5Ue73ZmG8Hb/42q6NjaP5Y5iZ/wx8mT9Aj2IdTH1emfRwghhH0kaRGNSrBH8CVbPry1BbiYzzPzxzwgr9x7bYu7ModNGH/bQaz7UHINbpWcIYp5+m4M1e7kyG8LIAyeXLIXF/N51k0ZLImLEELUM0laxBUj1MeVdVMGk5FnqvimqqKeWoUh/ihLIs+j3nljpefQ5bXG/M11tFNOAsE8dUNbZv6YR0aeSZIWIYSoZ5K0iCtKqI/rJZOLjPvuIeWll3FZ8R1Rjz+EotVWUsobbpkJKycCEKVNATxrL2AhhBDVJkOeRZPhfdttaLy9KU5KqnyG3DJdR0PkIAAC/3gLFyppuRFCCFHnJGkRTYbGzQ3fkSMBOL9g4aULKgpcPRUAQ/YJpui+qYvwhBBCXIYkLaJJ8b33HtDpyN+5k8K4uEsXdPWxPX1IuxKPkxtrOzQhhBCXIUmLaFL0QUF4xcQAcH7hZ5ctn9XyFjSKSosNT8raREIIUc8kaRFNjt9Y6+RxWStXUnzmTJVlz3Uez5+WluiKMuCbsVAi/VuEEKK+SNIimhzXzp1xu+oqKC7m3CefVFlW1Rr4v+InMRu84NROWCeLKgohRH2RpEU0Sc0eewyAzG+XUpyaVmXZU2oAp4a8Y32x7UPYt6S2wxNCCFEJSVpEk+TWpzeuPXuimkyc//R/ly2fE3EjDJxsffHDBEjaVssRCiGE+DtJWkSTpCiKrbUlY8nXlJw9e/mDrn0R2t8KZhMsvhcyEms3SCGEEOVI0iKaLPcB/TF27YJaWMjZ//z38gdoNHDHfyG4K+SfhUWjoDCr9gMVQggBSNIimjBFUQh48kkAMhYvxnTy5OUPMrjD6MXgGQzph2DRP8CUX8uRCiGEAElaRBPn3r8/7gMGQHEx6e/Ort5BXiFwz9fg4g1JW+Dr+2QotBBC1IEGmbR88MEHREZGYjQa6du3Lzt27Kiy/DfffEP79u0xGo107tyZlStX2t4rLi7mmWeeoXPnzri7uxMSEsKYMWM4c5n5OUTTEfDUFFAUsleupGD/X9U7KLgL3Ps16Fzh2Dr4bjxYzLUbqBBCNHENLmlZsmQJkydPZvr06ezevZuuXbsSExNDWlrlw1K3bNnC6NGjGTduHHv27GHEiBGMGDGCv/6yfvnk5+eze/duXnzxRXbv3s13333H4cOHue222+ryY4kGzBgdjdewWwFIe+stVFWt3oHhV8E/vgCNHuKWwfePgLmk9gIVQogmrsElLe+88w7jx4/ngQceoEOHDsybNw83Nzc+/fTTSsvPmTOHoUOHMnXqVKKjo3nllVfo0aMHc+fOBcDb25u1a9cycuRI2rVrx1VXXcXcuXPZtWsXSUlJdfnRRAMW8OSTKC4u5O/YQc6qVdU/sPX1cNenoNHB/m/gm/uhpKj2AhVCiCZMV98BXMxkMrFr1y5iY2Nt+zQaDddffz1bt26t9JitW7cyefLkcvtiYmJYtmzZJa+TlZWFoij4+PhU+n5RURFFRRe+eLKzswGwWCxYLJZqfpr6Y1Ettsf6jLesvhpDnWmDg/F7eDzn3p9L6htvon4+C7ioLqv6HO1vhbs/Q/l2LMqhFahfjUYd+TnoXe2OozHVWUMi9WY/qTPHSL3Zz5l11aCSlrNnz2I2mwkMDCy3PzAwkEOHDlV6TEpKSqXlU1JSKi1fWFjIM888w+jRo/Hy8qq0zIwZM3j55Zcr7D916pQtgWnIzp09Z3usz9YkVVXJyMhAURQURam3OKpLveEGlG+XUpKcTN7cBdDpQl2mpKTgZa5ieLNrR4zXvU/AL0+iiV9P0Sc3kXbtu1hc/e2LoZHVWUMh9WY/qTPHSL3Zz5nfmw0qaaltxcXFjBw5ElVV+eijjy5ZLjY2tlzrTXZ2NmFhYbRo0eKSrTMNiX9+CiSAfzN/wsPD6y0Oi8WCqqqEhYWh0TS4O5GVyp0+ndOPPorHyo2EBYB/b3/gHEFBQYSHeld9cHg4hIShLh6NMX0fYWseQB29GJq3r/b1G2OdNQRSb/aTOnOM1Jv9MjMznXauBpW0NGvWDK1WS2pqarn9qampBAUFVXpMUFBQtcqXJSwnTpzgl19+uWQrC4CLiwsuLi4V9ms0mkbxS6pRNLbH+o63rM7qO47q8hoymOwbridn7Toe/wksQ63NmsfP5lfvM+g7YRj2PRFrHsAl8wSW/8Vw8roPyW1xdblivu4GQn0qv33U2OqsoZB6s5/UmWOk3uzjzHpqUEmLwWCgZ8+erF+/nhEjRgDWrHb9+vVMmDCh0mP69evH+vXrmTRpkm3f2rVr6devn+11WcJy9OhRNmzYgL+/fU32omkJmjaN7O3baJWSS+4Pq3DVD2DSkr12ncOXWP5reIfepiOEr7yP98y3817JHVhK+7676rWsmzL4komLEEKIihpU0gIwefJk7r//fnr16kWfPn2YPXs2eXl5PPDAAwCMGTOG0NBQZsyYAcCTTz7J4MGDmTVrFrfccguLFy/mjz/+4L//tU7LXlxczF133cXu3btZsWIFZrPZ1t/Fz88Pg8FQPx9UNFi65s3hXw/By7NxX/Q9axbcRXZIpN3nUczXcX7LNPwOfcUk3Xc8FJ7KyWve43CuK5OW7CUjzyRJixBC2KHBJS2jRo0iPT2dadOmkZKSQrdu3Vi9erWts21SUlK5pqb+/fuzaNEiXnjhBZ577jnatGnDsmXL6NSpEwCnT5/mhx9+AKBbt27lrrVhwwaGDBlSJ59LNDI3DGT7V3Poe8RMyb9foMPXX6NxdSDBCJ8H+66BFZPwOLOZ6O9jcO//KnDp25NCCCEq1+CSFoAJEyZc8nbQxo0bK+y7++67ufvuuystHxkZWf3JwoQooyh8MlRDn7OeFB09RurrrxP8yiuOnavrKAjpBt88AGkHCF/3KO/rr0JbEA1cpnOvEEIIG+lFJMQlZLkrMP1JUBQyv/mWrB9XOH6y5u3g4Q1w9VRURcsw7TbafHMN7PxEpv8XQohqapAtLUI0GL260Oyxxzj74YekTJ+OsX07XNq0cexcOhe49gXi/QZT/N1jRBedhJ+mwB/zYegMaHn15c8h6sTpzAIy8py7CGZVI8aEENUjSYsQl9Hs8f8jf9cu8rdv5+Rj/0fk10vQ+fk5fL7C5l0Ybnqd365NIGT3O5D6FywcBi0Hw+BngFDnBS/sdjqzgOtnbaKg2LktYDJiTIiak6RFiMtQtFpCZ79L4shRFJ88yamJE4n49FOUGow8M6PlfMexhAz4J2ycAbsWQMImNAmbCAzuA4P/BW1jQKN13gcR1ZKRZ6Kg2MzsUd1oHeDhlHMeS8uVEWNCOIEkLUJUg87Xl7CPPiTxH6Mp+GMXZ55/gZA330Cp6aRJ7v5wy9swYCL89g7qni9wTd4Bi0eDbyT0Hg9dRoJHgFM+xxXHXAKFmZB3FpfUg1DwFxRmQVEOmHKgKBdMuWDKK91X+rykCCwlf9usLSttVS1rDWZa/OaNq9EIBndw9QFXP3D1BTc/8AoFn3DwDgOPQJBJxoSoE5K0CFFNLq1bE/ruO5x87P/I/vFHtJ6eBL74gnPWH/EJh2GzUQdMInv9O3jFL0PJSISfn4e10yDqGug80tr64upT8+s1VCUmyEuD3FTIvegx/xzkn4eC8xc9ZkCRdT0oDRDspBAMQBsNcP509Q7Q6MGvFQR2gIAOEBANgZ2sSaesTSOEU0nSIoQdPAYNIuSNNzgzdSoZixah8fKk+ZNPOm/hNJ9wMnpPxnPYayh/fQt7PofTu+DYOuumaCGsL7S9ESIHQVAX0DXwCRItFmvSkZvK2dSTFJ4/g64gHV1++kWPaegKzqIrynToEtmqGxmqBxl4kKV6kIMbuaqRPFzJxUi+aiQPI7mqK3kYKUJPCVrMqpZitJjRUIIWBRUDJXjoVN65K5pmRsXaOlOQcWHLOwtZpyDrJGSfAUsxnD1s3Q58fyEo9+bWn1VYH9yMHdFT4pz6FKIJk6RFCDt533oLltwcUl56mXPz/gNmM80nT3buiq8Gd+j1gHU7ewz2f2P9Qjx7GJK2WDcAnRFCekCLXta/8pu3g2ZtwcU5fTGqZC6xtorkpFhbRHJSSp+nQE7qhce8NOvtF6BZNU5rUrWk40O66s3Z0u0cXmSonmTiQabqQYbqQSYeZKiemPRezL23F6ac8wQFBeGv0VDThTp83Q00q07fE3MJZJ+Gs0chLQ7SDkLaAetjXjocWgGHVtAK2ONixLJmIHQaClHXgn9UDaMUoumRpEUIB/j+4x+oRUWkzniDcx9/giUvn8AXnq95H5fKNGsN18Rat4xEOLrW2upycrv1L/+Lk5gyHkHgFWLdPIPBzR9cPC9seldAKb19UfqoWqA4H0z51sfiArJzsjDlnkdXmIG2KBNtYQbaogzra5N9y80XGfw4XuiBf2AL9N5BlLg1p8Q1oPSxue212cUbFAUdEFS6VcXX3UCwlwtJSQWEh3rX7SJ2Wh34Rli3Ntdf2F9cCMn74NQOOLmdkoQteBSeg6R11g2st4/a3QzRt0FYH+l0LUQ1SNIihIP87r8fxehKyksvkbFoESUZ5wmZMQON0Vit44+l5VbYZ7FYSEkvIFubdYkvX18IHWndVBVD1nHcUnfhevZPPLLjcck4WtonpLTF48zuGn3Gyy02UKJqSMeHNNW6pas+pOFDmupr25em+nAWb0oKddZhv/cOJsDJI2gsFotTz1djeiOE97VuPMGhUxk888EiZnZLJyJzG26pf6DJSIRtH8K2Dyl2bU52ZAzZLW8iL/gqaz+ZapC5X0RTI0mLEDXgO2okGjdXzjz3PDmrVnPi9BnCPphrXXTxUse4G3DVay+zcvRxO6IIAUIuzANiKLC2yOQkW/tcZJ+5MKKmbCspAFUF1AuPigb07tZWGL0rGSV6Vh7MpHf7lnj6B2J28cVs9MHs4kuJ0bf0tS8oGrRYO8JerjNsU/2S9fUwclwXxS17IoHeuFHIQM1+YrQ7uUGzG6+CdPwPfoH/wS84r3qwwtyPZeYB7FbbAJe+7Shzv4imRpIWIWrIe9gwdIGBnH5iIoV//knCXXcT+s4s3Hr2rLR8qI8r66YMrnTGVYvFQkpKCkFBQXbd5iibB2RnwnkyAjyAKPCMAk8cnqvuWFouz+/fy4prBhIcKmsk1UTlP3Pr7aSTZhPuZ7bglbgKr8Sf8Ss8xxjdWsbo1mLyDCezze1kRt2OyadVuXPK3C+iKZKkRQgncO/Th8glizn52P9hSkjgxJj7af7kk/g/NK7Sfi6hPq6VftFYLBa8zFl2982oXuuN/Vz1WnzdG/jopEbiUj9zAMKHw1XDrR17EzZZO17H/YAhJ4mA3XMI2D0HQntCl1HQ8Q7wuHRLnhBXMklahHASQ2Qkkd98Q8pLL5G9YgXp77xD7qZNBL/6Ci4tW9bqtatqvamJpno7p95oddD6Out2yyw4vAr+XALH1luHvp/eBWueg9bX4xV2Gy641XfEQtQpSVqEqMLxLHv6lpR6dix0DIP35lOwaxfxw0fAQ6Ng1DDQVT5CxNfFl2CPmk2PVuVf8qLxMbhD57usW246HPgO9i22dq4+sprwI6vZ6eJGyW8joP/91jlhZDI7cYWTpEWISvi6+OKqcyX2t1jHTqCB5mNVHl6l0DXRBB9+zolvPuez6zTsb1nxto+rzpXlw5cT6BZYw8jFFcmjOfR9xLqlH4E/F2Pa/RVeeWfg0CLr5hsJXf4BXUdZZ+gV4gokSYsQlQj2CGb58OVkFGXU7ET3qqgrN8D7C4lIz+XFxRbUAd3h8TEQ0QKwtubE/hZLRlGGJC01lJyXTJYpq06u5YzWMYc0bwvXTeNIuyd47cOP+bDTEXwTV1lHjG16w7qFXQVd/wEdR1jXSxLiCiFJixCXEOwR7JwvpTEdMd/2T9I/+JCMr75C2bwLtuzG6+abafbYo+ArfxU7Q1phGo8vf5xCc2H5N1QV90Jolg3uhSquJnArBK0KammRYh3kGSHPRSHHFc55QYmu6lstZa1j9ZK4ACgatlo6cnrwI/jeNQcOrYR9X8HxDXBym3Vb9Qy0uwm6jrb2k9FWb/4XIRoqSVqEqANaHx+Cnn8O39GjSXtnFrnr1pP9009kr1wJQ66ibYuy+VKEo7KLszFmFfBms7EEnSmEowmQcBJS0lEKCi9/gr9Rm/lBcHMIDoTWEdA6Etq2BF/vcq1j9Za0lLJOUugB/jfCtTei65uCd/xyfI98izHjMMQtg7hllBj9yYy6jcw2d1LYrDMWVa0wkaF0vBYNnSQtQtQhl1YtCZs7l8KDBzn74UfkrF2LsmErrwLqjmfIeuAh1A4d6jvMRsNSUED+jh3kbPqVwPU/899UM/C/Sstq/fzQ+vig8fRA6+4Bep01UbSoqEVFmHNysGRnU5KRgVpQgHL2PJw9D/sPw88XzqMLCKBVpyhu1FmgQxKqX7Rz152qpqqHuXcEOtBBOcHt2t8Zod1M88JzNDswn2YH5nPEEsp35kEsMw8g5aKVmmSyOtHQKaoqf95dTnZ2Nt7e3mRkZODj41Pf4VzWjwd38NyOcbze538Mi+5Tb3FYLBaSkpIIDw+v2/VgGpHCw0c4/vEcilf9gsFcutPbG9/ht+Fzxx0Y27ev1/gaGlVVMSUmkvfbb+T++hv5O3eiFhXZ3rcooES0wLtjV4wdonFp2xZ9aAv0IcHVXl5BVVXMmZkUnzpN8elTmBJPUHj4EEUHD2E6caJCi5jWzw/3AQPwvGYI7oMGofX0dOZHrtLpzILqDXO3lOBx+jd8ji7FK3ENGrO1zlQUcoP7kR01jH0eg/i/ZUmseGIgnWQywUuS/9fsl5mZia+vL1lZWXh5XW5xkKpJS4sQ9cjYri3EPs5jUZv4pPAf6JetoyQ1lYzPPifjs89xad8e7+HD8Yq5EX1ISH2HWy8sBQXkbd9O3q+/kfvbbxSfPFnufV1wMO4DB3I80pt/meez8M45hPo73lqlKAo6X190vr64du5UPpa8PArj4kj8dRX71y6mc7Ie8/nzZP/4I9k//gg6HW69euF54w14DR2Kzs/P4Tiqw65h7mEj4KoR1iUd4paj7luMcmIznslb8EzeQoii5XN9NL4H7wWfkeBenTW5hahbkrQI0QDkuCkw8g5a/d9UEpctw7B5C3kbNlB06BBphw6R9uabGDt2xPOG6/G8/noMUVH1ckuiLqiqiikhkbzffr3QmmK6qDVBr8etZ088Bg3C4+pBGFq3RlVV4g78QuHu2q0Tjbs7br17Qyt3Xm32DUtiPiPipImcjRvJ3bAR0/Hj5G/bRv62baS+9jru/frhdcsteN5wPVoPj1qNrdqM3tBjDGq3f3L6wFZCMrejiVuGkryPQdq/4PdY2PwCtBwEHUZA9DBJYESDIUmLEA2Iotej7duX0LvvRs3OJnvVKrJXriJ/1y4KDxyg8MAB0mfPQRcUhHu/frj374f7VVdVuUBjfUrOTa7esPHsXNhzAHbug+17UM6klXtbDWwGV/WAft2hR2fy3F3JA1IphvMHUS0qp/JP1c6HqMLx/JPQqhW0ugUevAVOJcOvO2DdZpTD8eT9/jt5v//OmenTYGAvGDoE+nYDnX3/9dbW8OoSz1DoOAkGTebIwX1898WHPBn8F65n/4LjG63bT1MgcqA1eWl3E3i3cHocQlSXJC1CNBDHs46jWlSSc5LJO5eHolHgxq7WLSMLft8Jm7bDrv2UpKSQ9f33ZH3/PQBqSAB0aAMd21ofW4WDW+W3DepqfpHk3GSGLx9OQUlBhffcClWiklU6nVDpnKjSKgU0F3UVKdFAXLjC3lYKe6IUTvtngPILZP0CGy59TaPWiK9L7c9LUuXkg17AHRB8TsuAOJUBcRZCzxfDL1vhl61kucHvHRR+7aQhIYhqzWJbF8OrTV6RzDPfxq23z6ST6zmIWw4Hvofkfdb1kBI2wcqnIKgLtL/FmsAEdZFZeEWdkqRFiHpW7dl3FWAIGAaotDuloUui9Qs/MgU0Z9LgTBqs22wrnu4Fp5opnGoGp/0V0r0h3Vsh38+Vb+/8odYTl4yiDAqK85nZ6Tkizmutw48PxUPcUZQTpyuUVyNCoWdn6NMNbc9OdHZzpTNwXzWupVpUklOSiY6MrpOEzK7JB1UV9UgCrN4Ea3/DOyOLW/5QueUPM2pkCxg6GG68GgIrvwVT18Orj6XlQoA/tHwQWj6IITsRr4RVeJ5Yi1vqLpSUPyHlT9g4A5N7CDkRN5ATcQN5wX1RtS4VzifDqIUzSdIiRD27+Auw7Ms3OCjY2tJSHTl5qAePQdxRiDsCh+JRzmXSPBuaZ6t0Pw4XplEDyCVj3u0UhrSwDgP29UHn64fW1xetny9aLy8UoxGN0RWNm2vpcyNoNGCxWL+ELRawWLDk52PJy8OSm4s5J5eS9HRKUlMpSUuD04nMjzfjXvRKpWHrW7TAtUd33Pv1x73fVeiDghyuQ4vFgnueO8HudTdnil2TDzbrCP1vRX2xmNzNm8n+4Qdy1q2HxFMw70v4zyLcrupr7XR9ww1o3N1rN/hKVD2EujPQGT+yuVa7hxs0uxik2Y9b3hn84xbiH7eQHNWVrZYO/Grpwq+WLiSp1tmdZRi1cCZJWoRoAMq+AMu+fMP97RhO6Q9E9oabLuwyZ2ZSdPw4RUePURR/DFNCIsVnzlB0+hRKYRFKRhaFGbU73b0CuAOqRoNLWBiGqCiM7dth7NIF1y5dan1kTUOk6PV4DhmC55AhmLOzyV6zhuzlP5D/xx/kb91G/tZtpLz8bzxvuB7v4cNxv+qqOout+iuF3wxAQkkh7mc243ViLZ4n1uJZkM6N2l3cqN0FQJFXBKf9+vP6kRCyMjoT6hNay59ANAWStAhxBdL6+ODWowduPXqU238m5wz3LhmOx7kC/HJUPAvAKx+8ClQ8863PXU0qLiZwKQGX4gsbgKpY22xUxboVGqCgdMt3Uchyh/OecN5T4bwnZDQz8sH93xHiF1H3ldDAab288L37bnzvvhvTqVNk//gjWcuWYzpxguwffiT7hx/RBQTA9f0Ic62b6bTsWyncGyLugH53WFvgUvbBsfUQ/wuc3I5L9glaZZ/gEwOon82BFr0gcgBEDLCuSO3SQEZTiUZFkhYhmpAQzxAW/eOHmi8EWepyNzHqbVHBRsbQogXNHnsM/0cfpXDfPrJ++IHsn1ZSkpaGsmg5swD116c4d+dIvG+5peGNFtNoIKS7dbv6KSjKgYTfOPfnKrL/WkNLTeqF9ZB+mwUaHQR3u5DEhF9lHYotxGVI0iJEE+O0hSCF0ymKgmu3brh260bAs8+Su2kTp775EvPv29EdTSDtjTdJe3Mmrl264D74ajwGD8YYHY3S0GZmdfGE9jeT7DmAW3cPZc39YbQr2AcnNkPiZshKgtN/WLfNcwAFmreH0J7Qoqf1MaAjaOUrSpQnvxFCCNEAaQwGvG64AXqE8vDXI/mf/kHc1u6gYN8+23b2vffRNm+Gx4CBuPXpg1ufPhhaNLy+IwcL/SkOvA0Cb4M+oM85hXvyNtyTt+OWsg2X7BOQftC67f0CAIvWSEGzzhQ070qhfzSFftEU+bZB1brIiKQmTJIWIYRo4HLdFLh1KJEPTaY4JYXcX38l99dfyduyFXP6WbKWLSNr2TIAdCHBuPfujVvv3rj26IkhMqLeWmKqHpEUBAwHhtOcTLpq4umqiaebcoyumni8zAW4p+7EPXWn7YgSVUO8GsJuIvAYNATviK7g3xp8IqRVpomQn7IQQjQCx7OOW5/oges6WTfTeNgXB3/sh71xcPAYJWeSyVr+A1nLfwBA9XCD9q2hQ2uIbg3RbaC5X8WJDEs5sx9S9UcklZekWjBkHcctbQ+uZ/djPH8I47k4dKZs2imnaMcp2LwZyqYl0ujAt6U1gfGPsj76tQTvMOsMvrqK88eIxkmSFiGEaMCqNflgmHVziYG2pzV0SFLpkKQSlQKG3Hz440/rVuq8ByQGKpwIgKTmCkkBCmf8wKxVnD77rn0jki7Soid07HnhtapC9mkS43bw9YpVPNIuH+/cBDgfDyWFcO6odauMR6A1eSlLYjyDwb05eDS3ProHgJu/tNY0AvITEkKIBsyu2Xf/rqQE9fhJOHgU4o5ZHxNO4ZdrwS9XpUc8lE08qOp0mMKbs80thYy0/+HeoQ+GyEgMEeHWyQXrm6KAdwtywz350OxC287daB3gAaoFfV4yhqzjuGQlWB8zj6PPPYUh5xQacyHkplq307sueXoVBcXND9yaWUcyGb2sjy5e5Z+7eOKWmQtFYWBwA70r6IwVH7UG0GhlmQMnk6RFCCEauBqN+ArsAv0uvLTk5VF46BAFhw9zbtcu9GfOYDp8BEt+Pi7HkxkM8NeXnOZL2zG6kGBcIiPRh4ejDwpGFxSIPigYfXAQusDAOk1qLt1PRgFalW5lVHzJIUQ5R6hyllDlLCHKOZormTQji2ZKNv5KFn7koFVUyD9n3aqgAQLsiFdVtKgaHaqihdJHVaMDjRZV0aFqtFD6qCpaULSoiqa0rKb0tba0fNl71mNRNKXHl+5XdKgazYXzlHuv9LqKptx1XI0ueLsZSxMs63XR6q1Jl1YPmoue27u/FhK2Bpm0fPDBB7z11lukpKTQtWtX3n//ffr06XPJ8t988w0vvvgiiYmJtGnThjfffJObb77Z9r6qqkyfPp2PP/6YzMxMBgwYwEcffUSbNm3q4uMIIUSDoXF3x61nT4zdu5PTvz/h4eEoQPGZMxz7Yx1LVr7FKNeBuCZnYkpMxJKdTcmZZErOJMOWrZWeU+vri9bfD62Pj23TlT5qvL3RuLqhcXNF42rdlIteKwYDik6HoteDTodymS86R/vJVKYESAXicgp47stNeJScx0/JwYt8PJV86+PFzxXra6NSjBGTdVNMuGDCiHWfXjGXu4aimlHM5kqvf8XT6EBrQCnWOu2UDS5pWbJkCZMnT2bevHn07duX2bNnExMTw+HDhwkIqJjfbtmyhdGjRzNjxgxuvfVWFi1axIgRI9i9ezedOnUCYObMmbz33nssXLiQli1b8uKLLxITE0NcXBzGhtDsKYQQ9UjRaDC0aAGuffguS0PvQcNo5d3K2o8kKwdOnoGkM3A6FdLPQdpZSDsHaedQCoswZ2RgznDOhIWqTgd6Hei0oCt91Ous/U20GuumaNBoNda/5DWaizblb4+lm6KUHqfYjreVUzQ0V+D9YgvFZkslEWlB8QQ8rfGpkFdUSImLkTwFrC085T4BWMxYbzipULapKopqfa5y4XnZ7TlFtdjKlZ1H+dvrC++XnRsMaHBVdIDlwjWU0nOWe1StkSoXjjdbLJzOzEdFRaNYj9OgolEsaBQVrWJBiwWtYkarqGhszy3oFAtazGhKn+sU84WGFUW9qJHFQk5xiZ2/BZemqKqtRhqEvn370rt3b+bOnQtYF0ILCwvjiSee4Nlnn61QftSoUeTl5bFixQrbvquuuopu3boxb948VFUlJCSEKVOm8NRTTwGQlZVFYGAgCxYs4B//+EeFcxYVFVFUVGR7nZWVRXh4OAkJCfj4+Dj5EzvfqiO7eGX3E7zY431uatvz8gfUEovFwsmTJwkLC6v+OjpNnNSZY6Te7FdZnaXkpXDPynsoNBdW7ySqilsh+OWCZ76KRyF4FFD6aH3tXgiGEnApVm1LQhiLwVD6KK58uRYz1x4/TmZmJt7eNZz5WG1AioqKVK1Wq37//ffl9o8ZM0a97bbbKj0mLCxMfffdd8vtmzZtmtqlSxdVVVU1Pj5eBdQ9e/aUK3P11VerEydOrPSc06dPvzgFlk022WSTTTbZarjFx8c7lBtcrEHdHjp79ixms5nAwMBy+wMDAzl06FClx6SkpFRaPiUlxfZ+2b5Llfm72NhYJk+ebHudmZlJREQESUlJNc8Sm5Ds7GzCwsI4efIkXl5e9R1OoyB15hipN/tJnTlG6s1+ZXcr/JywsnuDSloaChcXF1xcKk5G5O3tLb+kDvDy8pJ6s5PUmWOk3uwndeYYqTf7OePWbYO6+dusWTO0Wi2pqanl9qemphIUFFTpMUFBQVWWL3u055xCCCGEaHgaVNJiMBjo2bMn69evt+2zWCysX7+efv36VXpMv379ypUHWLt2ra18y5YtCQoKKlcmOzub7du3X/KcQgghhGh4GtztocmTJ3P//ffTq1cv+vTpw+zZs8nLy+OBBx4AYMyYMYT+f3v3HhPF1f4B/LvC7rKIusidIpcKXiiwcpGVQIsRCrVoQI2xRhoaTVopRsR6bQRsLS7hDa31UihqBKMtBQ22tt4ICt5RFlhBKKBCaRRFrcAKcql7fn/wY+IUUODl7bLyfJJJ3HMOc5593GSezJyZeeMNKBQKAEB0dDT8/f2RnJyMkJAQZGZmoqioCGlpaQC6X/W+Zs0afPXVV3BycuJueba2tkZYWNiAYhKLxYiPj+/zkhHpH+Vt8ChnQ0N5GzzK2dBQ3gZvOHM24m55BoDdu3dzD5ebMWMGdu7cCblcDgCYPXs27O3tkZ6ezo3Pzs7Gli1buIfLJSUl9flwubS0NDQ1NcHPzw/fffcdpkyZ8m9/NUIIIYQM0YgsWgghhBBC/mlErWkhhBBCCOkPFS2EEEII0QlUtBBCCCFEJ1DRQgghhBCdQEXLAOzZswf29vYwMDCAXC7HtWvXtB3SiHH+/HnMnz8f1tbWEAgEOHbsGK+fMYa4uDhYWVlBIpEgMDAQNTU12gl2hFAoFJg5cybGjRsHc3NzhIWFoaqqijemvb0dUVFRMDExgZGRERYtWtTrAYmjTUpKCtzc3Lgnkfr4+ODkyZNcP+Xs1RITE7nHQPSgvPW2detWCAQC3jZt2jSun3LWt7t37yI8PBwmJiaQSCRwdXVFUVER1z8cxwMqWl7hp59+wtq1axEfH4/i4mLIZDIEBwejsbFR26GNCK2trZDJZNizZ0+f/UlJSdi5cydSU1NRWFiIsWPHIjg4GO3tA3yL7GuooKAAUVFRuHr1KnJzc9HV1YWgoCC0trZyY2JiYnD8+HFkZ2ejoKAA9+7dw8KFC7UYtfbZ2NggMTERSqUSRUVFmDNnDkJDQ3Hz5k0AlLNXuX79Or7//nu4ubnx2ilvfXvrrbfQ0NDAbRcvXuT6KGe9PXnyBL6+vhAKhTh58iQqKiqQnJwMY2NjbsywHA/+61cuvua8vb1ZVFQU9/n58+fM2tqaKRQKLUY1MgHgvaFbo9EwS0tL9p///Idra2pqYmKxmP34449aiHBkamxsZABYQUEBY6w7R0KhkGVnZ3NjKisrGQB25coVbYU5IhkbG7N9+/ZRzl5BrVYzJycnlpuby/z9/Vl0dDRjjH5r/YmPj2cymazPPspZ3zZu3Mj8/Pz67R+u4wGdaXmJzs5OKJVKBAYGcm1jxoxBYGAgrly5osXIdENtbS3u37/Py9+ECRMgl8spfy9obm4GAO4NqEqlEl1dXby8TZs2Dba2tpS3//f8+XNkZmaitbUVPj4+lLNXiIqKQkhICC8/AP3WXqampgbW1tZ48803sWzZMtTX1wOgnPXnl19+gZeXFxYvXgxzc3O4u7tj7969XP9wHQ+oaHmJR48e4fnz57CwsOC1W1hY4P79+1qKSnf05Ijy1z+NRoM1a9bA19cXLi4uALrzJhKJIJVKeWMpb0BZWRmMjIwgFouxcuVK5OTkwNnZmXL2EpmZmSguLuZeffIiylvf5HI50tPTcerUKaSkpKC2thZvv/021Go15awfd+7cQUpKCpycnHD69GlERkZi9erVyMjIADB8x4MR9+4hQkaTqKgolJeX866Xk/5NnToVpaWlaG5uxpEjRxAREYGCggJthzVi/fnnn4iOjkZubi4MDAy0HY7OmDt3LvdvNzc3yOVy2NnZISsrCxKJRIuRjVwajQZeXl7Yvn07AMDd3R3l5eVITU1FRETEsM1DZ1pewtTUFHp6er1WhT948ACWlpZaikp39OSI8te3VatW4ddff8W5c+dgY2PDtVtaWqKzsxNNTU288ZS37jfBOzo6wtPTEwqFAjKZDN9++y3lrB9KpRKNjY3w8PCAvr4+9PX1UVBQgJ07d0JfXx8WFhaUtwGQSqWYMmUKbt26Rb+1flhZWcHZ2ZnXNn36dO6y2nAdD6hoeQmRSARPT0/k5eVxbRqNBnl5efDx8dFiZLrBwcEBlpaWvPy1tLSgsLBwVOePMYZVq1YhJycHZ8+ehYODA6/f09MTQqGQl7eqqirU19eP6rz1RaPRoKOjg3LWj4CAAJSVlaG0tJTbvLy8sGzZMu7flLdXe/r0KW7fvg0rKyv6rfXD19e316MbqqurYWdnB2AYjwf/zWrh0SAzM5OJxWKWnp7OKioq2Mcff8ykUim7f/++tkMbEdRqNSspKWElJSUMAPv6669ZSUkJ++OPPxhjjCUmJjKpVMp+/vlnduPGDRYaGsocHBzYs2fPtBy59kRGRrIJEyaw/Px81tDQwG1tbW3cmJUrVzJbW1t29uxZVlRUxHx8fJiPj48Wo9a+TZs2sYKCAlZbW8tu3LjBNm3axAQCATtz5gxjjHI2UC/ePcQY5a0vn332GcvPz2e1tbXs0qVLLDAwkJmamrLGxkbGGOWsL9euXWP6+vosISGB1dTUsMOHDzNDQ0N26NAhbsxwHA+oaBmAXbt2MVtbWyYSiZi3tze7evWqtkMaMc6dO8cA9NoiIiIYY923ucXGxjILCwsmFotZQEAAq6qq0m7QWtZXvgCwAwcOcGOePXvGPv30U2ZsbMwMDQ3ZggULWENDg/aCHgGWL1/O7OzsmEgkYmZmZiwgIIArWBijnA3UP4sWyltvS5YsYVZWVkwkErE33niDLVmyhN26dYvrp5z17fjx48zFxYWJxWI2bdo0lpaWxusfjuOBgDHGhnw+iBBCCCHkX0JrWgghhBCiE6hoIYQQQohOoKKFEEIIITqBihZCCCGE6AQqWgghhBCiE6hoIYQQQohOoKKFEEIIITqBihZCCCGE6AQqWgghhBCiE6hoIYSQAXj8+DHMzc1RV1f3P5vjgw8+QHJy8v9s/4ToOipaCCFkABISEhAaGgp7e3uuzd/fHwKBANu3b+eNZYxBLpdDIBDgyy+/HPAcW7ZsQUJCApqbm4crbEJeK1S0EEL+FZ2dndoOYcja2tqwf/9+rFixgmtjjKGkpAR2dnYoKyvjjc/IyMC9e/cAAB4eHgOex8XFBZMnT8ahQ4eGJ3BCXjNUtBAySh05cgSurq6QSCQwMTFBYGAgWltbAQAdHR1YvXo1zM3NYWBgAD8/P1y/fp37W3t7e+zYsYO3vxkzZmDr1q3c59mzZ2PVqlVYs2YNTE1NERwcDADQaDRISkqCo6MjxGIxbG1tkZCQwPUpFAo4ODhAIpFAJpPhyJEjL/0edXV1EAgEOHr0KN555x1IJBLMnDkT9fX1uHDhAmbNmgVDQ0MEBASgqalpSLk6ceIExGIxZs2axbXV1NRArVYjIiKCV7So1Wps3rwZH330EQDA09NzUHPNnz8fmZmZQ4qTkNcdFS2EjEINDQ1YunQpli9fjsrKSuTn52PhwoXoeen7hg0bcPToUWRkZKC4uBiOjo4IDg7GX3/9Nah5MjIyIBKJcOnSJaSmpgIANm/ejMTERMTGxqKiogI//PADLCwsAAAKhQIHDx5Eamoqbt68iZiYGISHh6OgoKDfOVQqFQAgJSUF27dvx+XLl/HgwQOEh4cjMTERu3fvxrlz56BSqXDgwIGhpAsXLlzoVXwolUoYGhpi6dKlqKqq4s4kbdu2DV5eXjAzM4OlpSWsrKwGNZe3tzeuXbuGjo6OIcVKyGuNEUJGHaVSyQCwurq6Xn1Pnz5lQqGQHT58mGvr7Oxk1tbWLCkpiTHGmJ2dHfvmm294fyeTyVh8fDz32d/fn7m7u/PGtLS0MLFYzPbu3dtr3vb2dmZoaMguX77Ma1+xYgVbunRpv99l69atbOLEiezRo0dcW3h4OLO3t2etra1c23vvvcc2bNjAfQ4LC2NSqZQtWrSo3333CA0NZcuXL+e1rVu3js2aNYtpNBpmZGTEVCoVq66uZkZGRqy6uppFRESw999//5X7/ieVStXv/w0hox2daSFkFJLJZAgICICrqysWL16MvXv34smTJwCA27dvo6urC76+vtx4oVAIb29vVFZWDmqef56dqKysREdHBwICAnqNvXXrFtra2vDuu+/CyMiI2w4ePIjbt2/3O4dKpcKCBQtgYmLCtdXX12PJkiUwNDTktTk4OHCfo6OjcfDgwQF9j2fPnsHAwIDXVlxcDA8PDwgEAri5uaGsrAwxMTGIjIyEk5MTlEplr+9/7NgxzJs3D0FBQdi/f3+fc0kkEgDd62gIIXxUtBAyCunp6SE3NxcnT56Es7Mzdu3ahalTp6K2tnZAfz9mzBjuUlKPrq6uXuPGjh3L+9xzQO7L06dPAQC//fYbSktLua2iouKl61pKS0shl8t5bSqVirf+pL29HVVVVZDJZFzb7NmzMW7cuH73+yJTU1OuqOvRU7QA3et5duzYgaKiIsTGxqK9vR2///47bxHu4cOHkZWVhZSUFBw6dAgVFRXcWp4X9VyCMzMzG1BshIwmVLQQMkoJBAL4+vriiy++QElJCUQiEXJycjB58mRuHUqPrq4uXL9+Hc7OzgC6D6gNDQ1cf0tLy4AKHicnJ0gkEuTl5fXqc3Z2hlgsRn19PRwdHXnbpEmT+txfS0sL6urq4O7uzrXV1taiubmZ11ZWVgbGGFxdXV+dmD64u7ujoqKC+3znzh00NTVxRYm7uzuKioqgUCgwbtw4qFQq/P3337wzLWlpacjIyMCkSZNgbm6O5ORk5OfnQ61W8+YqLy+HjY0NTE1NhxQrIa8zfW0HQAj59xUWFiIvLw9BQUEwNzdHYWEhHj58iOnTp2Ps2LGIjIzE+vXrMXHiRNja2iIpKQltbW3cLb9z5sxBeno65s+fD6lUiri4OOjp6b1yXgMDA2zcuBEbNmyASCSCr68vHj58iJs3b2LFihVYt24dYmJioNFo4Ofnh+bmZly6dAnjx49HREREr/2pVCro6enBxcWFaystLcXEiRNhZ2fHa5s8eTKMjIyGlK/g4GBs3rwZT548gbGxMZRKJUQiETdvREQEwsLCuEtUxcXFMDMz44qtx48fw9bWFkKhEPv27cPFixeRnp4OuVyO6upqXnFz4cIFBAUFDSlOQl53VLQQMgqNHz8e58+fx44dO9DS0gI7OzskJydj7ty5AIDExERoNBp8+OGHUKvV8PLywunTp2FsbAyg+w6g2tpazJs3DxMmTMC2bdsGfGkpNjYW+vr6iIuLw71792BlZYWVK1cC6L7zxszMDAqFAnfu3IFUKoWHhwc+//zzPvelUqkwdepU3noTlUrFO8vS0/bipaHBcnV1hYeHB7KysvDJJ5+guLgYLi4uEAqFALrX/Lx4ZqS4uJgXg7GxMXdmavHixQgJCQEAVFVV8c4itbe349ixYzh16tSQYyXkdSZg/7wwTQgho0R+fj527979ymfBAN1rbdavX4/y8nKMGTP4K+txcXGQSqVYu3YtACArKwsnTpxAeno6NyYlJQU5OTk4c+bMoPdPyGhAZ1oIIaNSYGAgVCoVWltbYWNjg+zsbPj4+PQ7PiQkBDU1Nbh7926/a2xeJi4uDlu2bIFMJoNAIMDMmTOxZ88e3hihUIhdu3YNet+EjBZ0poUQQgghOoHuHiKEEEKITqCihRBCCCE6gYoWQgghhOgEKloIIYQQohOoaCGEEEKITqCihRBCCCE6gYoWQgghhOgEKloIIYQQohOoaCGEEEKITqCihRBCCCE64f8AFx8/sXrYeH8AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from ler.utils import plots as lerplt\n",
    "\n",
    "# let's do a comparision plot between you custom model and the default model\n",
    "plt.figure(figsize=(6, 4))\n",
    "lerplt.param_plot(\n",
    "    param_name=\"mass_1_source\", \n",
    "    param_dict=custom_model_dict, # or the json file name\n",
    "    plot_label='custom model',\n",
    ");\n",
    "lerplt.param_plot(\n",
    "    param_name=\"mass_1_source\", \n",
    "    param_dict=default_model_dict,\n",
    "    plot_label='default model',\n",
    ");\n",
    "plt.xlabel(r'source $m_1$ ($M_{\\odot}$)')\n",
    "plt.ylabel(r'$p(source mass_1)$')\n",
    "plt.xlim(0,60)\n",
    "plt.grid(alpha=0.4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison of Axis-ratio model of the lensing galaxy. <a class=\"anchor\" id=\"bullet-three-two\"></a>\n",
    "\n",
    "* compare the default axis-ratio distribution (gengamma, from SDSS galaxy catalogue, Haris et al. 2018) with axis-ratio distribution from Padilla and Strauss 2008 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "axis_ratio_spline_coeff interpolator will be generated at ./interpolator_pickle/axis_ratio/axis_ratio_spline_coeff_0.pickle\n",
      "axis_ratio interpolator will be generated at ./interpolator_pickle/axis_ratio/axis_ratio_1.pickle\n"
     ]
    }
   ],
   "source": [
    "size = 10000\n",
    "padilla_strauss = ler.axis_ratio_padilla_strauss(size=size)\n",
    "\n",
    "# axis_ratio_rayleigh depends on the velocity dispersion\n",
    "sigma = ler.velocity_dispersion_gengamma(size=size)\n",
    "rayleigh = ler.axis_ratio_rayleigh(sigma=sigma)\n",
    "\n",
    "# make a dict\n",
    "axis_ratio_dict = dict(\n",
    "    padilla_strauss=padilla_strauss,\n",
    "    rayleigh=rayleigh,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the distribution of axis-ratio\n",
    "plt.figure(figsize=(6, 4))\n",
    "lerplt.param_plot(\n",
    "    param_name=\"padilla_strauss\",\n",
    "    param_dict=axis_ratio_dict,\n",
    "    plot_label='padilla_strauss',\n",
    ")\n",
    "lerplt.param_plot(\n",
    "    param_name=\"rayleigh\",\n",
    "    param_dict=axis_ratio_dict,\n",
    "    plot_label='rayleigh',\n",
    ")\n",
    "plt.xlabel(r'axis ratio')\n",
    "plt.ylabel(r'$p(axis ratio)$')\n",
    "plt.grid(alpha=0.4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating particular number of detectable events. <a class=\"anchor\" id=\"bullet-four\"></a>\n",
    "\n",
    "* this is particularly useful when you want only the detectable events to be saved in the json file\n",
    "\n",
    "* detectable event rates will be calculated at each batches. Subsequent batch will consider the previous batch's detectable events. So, the rates will become more accurate as the batch number increases and will converge to a stable value at higher samples. \n",
    "\n",
    "* you can resume the rate calculation from the last saved batch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ler.rates import LeR\n",
    "\n",
    "# class initialization\n",
    "ler = LeR(npool=8, verbose=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unlensed case. <a class=\"anchor\" id=\"bullet-four-one\"></a>\n",
    "\n",
    "* SNR>8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "removing ./ler_data/unlensed_params_n_detectable.json and ./ler_data/meta_unlensed.json if they exist\n",
      "collected number of detectable events =  0\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  422\n",
      "total number of events =  100000\n",
      "total rate (yr^-1): 436.86662367311965\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  841\n",
      "total number of events =  200000\n",
      "total rate (yr^-1): 435.31378022404454\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  1255\n",
      "total number of events =  300000\n",
      "total rate (yr^-1): 433.0707841309361\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  1705\n",
      "total number of events =  400000\n",
      "total rate (yr^-1): 441.2663467788323\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  2094\n",
      "total number of events =  500000\n",
      "total rate (yr^-1): 433.5538909817594\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  2503\n",
      "total number of events =  600000\n",
      "total rate (yr^-1): 431.8630170038777\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  2916\n",
      "total number of events =  700000\n",
      "total rate (yr^-1): 431.24680928599076\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  3325\n",
      "total number of events =  800000\n",
      "total rate (yr^-1): 430.2670390145505\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  3740\n",
      "total number of events =  900000\n",
      "total rate (yr^-1): 430.1951481141304\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  4138\n",
      "total number of events =  1000000\n",
      "total rate (yr^-1): 428.3777461515092\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  4561\n",
      "total number of events =  1100000\n",
      "total rate (yr^-1): 429.2435740140238\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  4979\n",
      "total number of events =  1200000\n",
      "total rate (yr^-1): 429.53375183026515\n",
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  5385\n",
      "total number of events =  1300000\n",
      "total rate (yr^-1): 428.8236909368846\n",
      "stored detectable unlensed params in ./ler_data/unlensed_params_n_detectable.json\n",
      "stored meta data in ./ler_data/meta_unlensed.json\n",
      "\n",
      " trmming final result to size=5000\n",
      "collected number of detectable events =  5000\n",
      "total number of events =  1207057.0\n",
      "total unlensed event rate (yr^-1): 428.8235626196801\n"
     ]
    }
   ],
   "source": [
    "n_size_unlensed_param = ler.selecting_n_unlensed_detectable_events(\n",
    "    size=5000, \n",
    "    snr_threshold=10.0,\n",
    "    batch_size=100000,\n",
    "    resume=False,\n",
    "    output_jsonfile='unlensed_params_n_detectable.json',\n",
    "    meta_data_file=\"meta_unlensed.json\",\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important Note**: At each iteration, rate is calculated using the cummulatively increasing number of events. It will become stable at around 2 million events. This is the number of events that is required to get a stable rate. Below, I am showing visualization of how rate changes with increasing number of events."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from ler.utils import get_param_from_json\n",
    "# getting data from json\n",
    "meta_data= get_param_from_json(\"./ler_data/meta_unlensed.json\")\n",
    "\n",
    "# plot the rate vs sampling size\n",
    "plt.figure(figsize=(4,4))\n",
    "plt.plot(meta_data['events_total'], meta_data['total_rate'], 'o-')\n",
    "plt.xlabel('Sampling size')\n",
    "plt.ylabel('Rate (per year)')\n",
    "plt.title('Rate vs Sampling size')\n",
    "plt.grid(alpha=0.4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lensed case. <a class=\"anchor\" id=\"bullet-four-two\"></a>\n",
    "\n",
    "* 2 images, snr>8 (super-threshold)\n",
    "* 1 image, snr>6 (sub+super-threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "removing ./ler_data/lensed_params_n_detectable.json and ./ler_data/meta_lensed.json if they exist\n",
      "collected number of detectable events =  0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:11<00:00, 4299.84it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 12.57it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == step_function\n",
      "collected number of detectable events =  112\n",
      "total number of events =  50000\n",
      "total rate (yr^-1): 0.508493641457471\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:11<00:00, 4296.83it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 11.66it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == step_function\n",
      "collected number of detectable events =  212\n",
      "total number of events =  100000\n",
      "total rate (yr^-1): 0.48125291066510645\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:12<00:00, 4094.12it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 38.02it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == step_function\n",
      "collected number of detectable events =  317\n",
      "total number of events =  150000\n",
      "total rate (yr^-1): 0.4797395367321973\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:11<00:00, 4289.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == step_function\n",
      "collected number of detectable events =  433\n",
      "total number of events =  200000\n",
      "total rate (yr^-1): 0.4914681847122432\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:11<00:00, 4318.64it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 12.09it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == step_function\n",
      "collected number of detectable events =  531\n",
      "total number of events =  250000\n",
      "total rate (yr^-1): 0.48216093502485197\n",
      "storing detectable lensed params in ./ler_data/lensed_params_n_detectable.json\n",
      "storing meta data in ./ler_data/meta_lensed.json\n",
      "\n",
      " trmming final result to size=500\n",
      "collected number of detectable events =  500\n",
      "total number of events =  235405.0\n",
      "total lensed event rate (yr^-1): 0.4821607228741339\n"
     ]
    }
   ],
   "source": [
    "n_size_lensed_param = ler.selecting_n_lensed_detectable_events(\n",
    "    size=500,\n",
    "    snr_threshold=[8.0,6.0],\n",
    "    num_img=[2,1],\n",
    "    batch_size=50000,\n",
    "    resume=False,\n",
    "    output_jsonfile='lensed_params_n_detectable.json',\n",
    "    meta_data_file=\"meta_lensed.json\",\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['zl', 'zs', 'sigma', 'q', 'theta_E', 'phi', 'e1', 'e2', 'gamma1', 'gamma2', 'gamma', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'x0_image_positions', 'x1_image_positions', 'magnifications', 'time_delays', 'image_type', 'n_images', 'effective_luminosity_distance', 'effective_geocent_time', 'snr_net', 'L1', 'H1', 'V1'])\n",
      "size of each parameters=500\n"
     ]
    }
   ],
   "source": [
    "print(n_size_lensed_param.keys())\n",
    "print(f\"size of each parameters={len(n_size_lensed_param['zl'])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using custom detection criteria. <a class=\"anchor\" id=\"bullet-five\"></a>\n",
    "\n",
    "* I leverage the ANN (Artificial Neural Network) based SNR calculator from gwsnr. It can predict SNR>8 with 99.9% accuracy for the astrophysical parameters. But to make it 100% accurate, I will recalculate SNR some of the events using inner product method. LeR can do this automatically. \n",
    "\n",
    "* I will test two cases using: \n",
    "  * pdet (probability of detection) with ANN\n",
    "  * SNR with ANN.\n",
    "\n",
    "* **Note:** Check out [GRB rate calculation example](https://ler.readthedocs.io/en/latest/examples/rates/grb%20detection%20rate.html) for more details on how to use custom detection criteria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ler.rates import LeR\n",
    "from gwsnr import GWSNR\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining custom detection criteria (using `gwsnr` package). <a class=\"anchor\" id=\"bullet-five-one\"></a>\n",
    "\n",
    "* pdet only calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "psds not given. Choosing bilby's default psds\n",
      "Intel processor has trouble allocating memory when the data is huge. So, by default for IMRPhenomXPHM, duration_max = 64.0. Otherwise, set to some max value like duration_max = 600.0 (10 mins)\n",
      "Interpolator will be loaded for L1 detector from ./interpolator_pickle/L1/partialSNR_dict_1.pickle\n",
      "Interpolator will be loaded for H1 detector from ./interpolator_pickle/H1/partialSNR_dict_1.pickle\n",
      "Interpolator will be loaded for V1 detector from ./interpolator_pickle/V1/partialSNR_dict_1.pickle\n",
      "\n",
      "Chosen GWSNR initialization parameters:\n",
      "\n",
      "npool:  4\n",
      "snr type:  ann\n",
      "waveform approximant:  IMRPhenomXPHM\n",
      "sampling frequency:  2048.0\n",
      "minimum frequency (fmin):  20.0\n",
      "mtot=mass1+mass2\n",
      "min(mtot):  2.0\n",
      "max(mtot) (with the given fmin=20.0): 184.98599853446768\n",
      "detectors:  ['L1', 'H1', 'V1']\n",
      "psds:  [PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/aLIGO_O4_high_asd.txt'), PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/aLIGO_O4_high_asd.txt'), PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/AdV_asd.txt')]\n"
     ]
    }
   ],
   "source": [
    "snr_ = GWSNR(gwsnr_verbose=True, pdet=True, snr_type='ann', waveform_approximant='IMRPhenomXPHM')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing the custom detection criteria. <a class=\"anchor\" id=\"bullet-five-two\"></a>\n",
    "\n",
    "* Pdet calculator test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 16.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pdet: {'L1': array([0, 0, 1, 0]), 'H1': array([0, 0, 0, 0]), 'V1': array([0, 0, 0, 0]), 'pdet_net': array([1, 0, 1, 0])}\n",
      "inner_product_snr: {'L1': array([ 7.4441411 ,  5.85368864, 10.6450267 ,  0.        ]), 'H1': array([4.73471203, 3.72313335, 6.77057773, 0.        ]), 'V1': array([2.23257635, 1.73563894, 3.21070705, 0.        ]), 'snr_net': array([ 9.10039185,  7.15121214, 13.01790904,  0.        ])}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# initialization pdet calculator\n",
    "pdet_calculator = snr_.snr\n",
    "mass_1 = np.array([5, 10.,50.,200.])\n",
    "ratio = np.array([1, 0.8,0.5,0.2])\n",
    "luminosity_distance = np.array([1000, 2000, 3000, 4000])\n",
    "# test\n",
    "pdet = pdet_calculator(\n",
    "    gw_param_dict=dict(\n",
    "        mass_1=mass_1,\n",
    "        mass_2=mass_1*ratio,\n",
    "        luminosity_distance=luminosity_distance,\n",
    "    )\n",
    ")\n",
    "inner_product_snr = snr_.compute_bilby_snr(\n",
    "    mass_1=mass_1,\n",
    "    mass_2=mass_1*ratio,\n",
    "    luminosity_distance=luminosity_distance,\n",
    ")\n",
    "\n",
    "print(f\"pdet: {pdet}\")\n",
    "print(f\"inner_product_snr: {inner_product_snr}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using custom detection criteria with LeR. <a class=\"anchor\" id=\"bullet-five-three\"></a>\n",
    "\n",
    "* Below is an example of general case of initialising with any type of pdet calculator.\n",
    "\n",
    "* Refer to the [documentation](https://ler.readthedocs.io/en/latest/examples/rates/grb%20detection%20rate.html) example for extra details, where I have used pdet for GRB (gamma-ray-burst) detection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ler.rates import LeR\n",
    "\n",
    "ler = LeR(verbose=False, pdet_finder=pdet_calculator, spin_zero=False,\n",
    "    spin_precession=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed params will be store in ./ler_data/unlensed_param.json\n",
      "chosen batch size = 50000 with total size = 100000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling gw source params...\n",
      "calculating pdet...\n",
      "Batch no. 2\n",
      "sampling gw source params...\n",
      "calculating pdet...\n",
      "saving all unlensed parameters in ./ler_data/unlensed_param.json \n"
     ]
    }
   ],
   "source": [
    "unlensed_param = ler.unlensed_cbc_statistics();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* now calculate rate using the custom 'pdet' calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting unlensed_param from json file ./ler_data/unlensed_param.json...\n",
      "given detectability_condition == 'pdet'\n",
      "total unlensed rate (yr^-1): 502.08604853427255\n",
      "number of simulated unlensed detectable events: 485\n",
      "number of simulated all unlensed events: 100000\n",
      "storing detectable params in ./ler_data/unlensed_param_detectable.json\n"
     ]
    }
   ],
   "source": [
    "_, unlensed_param_detectable = ler.unlensed_rate(detectability_condition='pdet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # for lensed case\n",
    "# lensed_param = ler.lensed_cbc_statistics()\n",
    "# _, lensed_param_detectable = ler.lensed_rate(detectability_condition='pdet')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analysis: SNR (with ANN) + SNR recalculation (inner product). <a class=\"anchor\" id=\"bullet-five-four\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ler.rates import LeR\n",
    "\n",
    "# ler initialization with gwsnr arguments\n",
    "ler = LeR(npool=6, \n",
    "    verbose=False, \n",
    "    snr_type='ann', \n",
    "    waveform_approximant='IMRPhenomXPHM', \n",
    "    spin_zero=False,\n",
    "    spin_precession=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "removing ./ler_data/unlensed_params_n_detectable_ann.json and ./ler_data/meta_unlensed_ann.json if they exist\n",
      "collected number of detectable events =  0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 1598/1598 [00:04<00:00, 351.02it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  204\n",
      "total number of events =  50000\n",
      "total rate (yr^-1): 422.373418148419\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 1557/1557 [00:04<00:00, 344.99it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  425\n",
      "total number of events =  100000\n",
      "total rate (yr^-1): 439.97231057126976\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 1503/1503 [00:04<00:00, 345.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == 'step_function'\n",
      "collected number of detectable events =  604\n",
      "total number of events =  150000\n",
      "total rate (yr^-1): 416.85219699615203\n",
      "stored detectable unlensed params in ./ler_data/unlensed_params_n_detectable_ann.json\n",
      "stored meta data in ./ler_data/meta_unlensed_ann.json\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "unlensed_param = ler.selecting_n_unlensed_detectable_events(\n",
    "    size=500, \n",
    "    snr_threshold=10.0,\n",
    "    batch_size=50000,\n",
    "    resume=False,\n",
    "    trim_to_size=False,\n",
    "    output_jsonfile='unlensed_params_n_detectable_ann.json',\n",
    "    meta_data_file=\"meta_unlensed_ann.json\",\n",
    "    snr_recalculation=True,\n",
    "    snr_threshold_recalculation=[4,20], # it will recalculate SNR for events with (SNR_ANN > 4) and (SNR_ANN < 20)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Uncomment the below code if you need to compare with the rate calculation using inner product snr\n",
    "\n",
    "from ler.rates import LeR\n",
    "\n",
    "# # ler initialization with gwsnr arguments\n",
    "# ler = LeR(npool=6, verbose=False, snr_type='inner_product', waveform_approximant='IMRPhenomXPHM', spin_zero=False,\n",
    "#     spin_precession=True)\n",
    "\n",
    "# unlensed_param = ler.selecting_n_unlensed_detectable_events(\n",
    "#     size=1000, \n",
    "#     snr_threshold=10.0,\n",
    "#     batch_size=50000,\n",
    "#     resume=False,\n",
    "#     output_jsonfile='unlensed_params_n_detectable.json',\n",
    "#     meta_data_file=\"meta_unlensed.json\",\n",
    "#     )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "removing ./ler_data/lensed_params_n_detectable_ann.json and ./ler_data/meta_lensed_ann.json if they exist\n",
      "collected number of detectable events =  0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:11<00:00, 4310.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 1538/1538 [00:04<00:00, 382.74it/s]\n",
      "100%|██████████████████████████████████████████████████████████| 1538/1538 [00:03<00:00, 389.81it/s]\n",
      "100%|██████████████████████████████████████████████████████████| 1084/1084 [00:02<00:00, 363.55it/s]\n",
      "100%|████████████████████████████████████████████████████████████| 964/964 [00:02<00:00, 377.48it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == step_function\n",
      "collected number of detectable events =  220\n",
      "total number of events =  50000\n",
      "total rate (yr^-1): 0.9988267957200324\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:11<00:00, 4299.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 1436/1436 [00:03<00:00, 387.69it/s]\n",
      "100%|██████████████████████████████████████████████████████████| 1436/1436 [00:03<00:00, 389.49it/s]\n",
      "100%|██████████████████████████████████████████████████████████| 1011/1011 [00:02<00:00, 375.16it/s]\n",
      "100%|████████████████████████████████████████████████████████████| 884/884 [00:02<00:00, 375.81it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == step_function\n",
      "collected number of detectable events =  430\n",
      "total number of events =  100000\n",
      "total rate (yr^-1): 0.9761261867263953\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:11<00:00, 4311.48it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 11.26it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 1525/1525 [00:03<00:00, 381.67it/s]\n",
      "100%|██████████████████████████████████████████████████████████| 1525/1525 [00:03<00:00, 390.52it/s]\n",
      "100%|██████████████████████████████████████████████████████████| 1066/1066 [00:02<00:00, 375.39it/s]\n",
      "100%|████████████████████████████████████████████████████████████| 919/919 [00:02<00:00, 379.79it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given detectability_condition == step_function\n",
      "collected number of detectable events =  662\n",
      "total number of events =  150000\n",
      "total rate (yr^-1): 1.0018535435858507\n",
      "storing detectable lensed params in ./ler_data/lensed_params_n_detectable_ann.json\n",
      "storing meta data in ./ler_data/meta_lensed_ann.json\n",
      "\n",
      " trmming final result to size=500\n",
      "collected number of detectable events =  500\n",
      "total number of events =  113293.0\n",
      "total lensed event rate (yr^-1): 1.001853997759663\n"
     ]
    }
   ],
   "source": [
    "lensed_param = ler.selecting_n_lensed_detectable_events(\n",
    "    size=500,\n",
    "    snr_threshold=[8.0,8.0],\n",
    "    num_img=[1,1],\n",
    "    batch_size=50000,\n",
    "    resume=False,\n",
    "    output_jsonfile='lensed_params_n_detectable_ann.json',\n",
    "    meta_data_file=\"meta_lensed_ann.json\",\n",
    "    snr_recalculation=True,\n",
    "    snr_threshold_recalculation=[[4,4], [20,20]], # it will recalculate SNR for events with (SNR_ANN > 4) and (SNR_ANN < 20)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed_rate: 416.85219699615203\n",
      "lensed_rate: 1.001853997759663\n",
      "ratio: 416.0807841544908\n"
     ]
    }
   ],
   "source": [
    "ler.rate_ratio();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ler",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}